Ensuring service availability for large-scale distributed systems, like IoT systems, has always been a challenge. Some IoT systems are safety-critical, a service outage could lead to severe damage or fatality, and therefore demand high-availability to ensure reliability and continuity of service. Microservice architecture combined with Kubernetes orchestrator have become a popular approach to achieve high-availability in such type of systems. However, while these architectures provide scalability and quick recoverability from many types of failures, their effectiveness is limited when addressing memory-related application failures. In this paper, we present an experimental evaluation of the service availability provided by microservice architectures deployed on Kubernetes in scenarios involving memory-related failures, through a case study on Tele-operated driving, which is a safety-critical cellular IoT use case. Our findings indicate that Kubernetes lacks robustness when confronted with memory-related faults, leading to extended recovery times and service disruptions. Therefore, advanced fault-tolerance mechanisms are required to better support high-availability requirements in safety-critical cellular IoT systems.

Safety-critical cellular IoT systems require a high level of reliability. Due to the distributed and heterogenous nature of such systems, software applications are usually deployed on different platforms including IoT devices, on-premises servers, cloud, and edge nodes. Traditional monolithic software applications cannot provide the desired level of reliability and flexibility. The microservices architecture, on the other hand, may provide better scalability, reliability, and decentralization. Furthermore, when coupled with efficient container orchestration platforms, like Kubernetes, microservices architecture can improve further the reliability for safety-critical cellular IoT systems. In this paper, we look into the Tele-operated Driving (ToD) case study. It is a safety-critical cellular IoT system which requires a high level of reliability and availability. We propose an initial microservices based architecture for the ToD. We conduct experiments to evaluate the service availability of the proposed microservices based ToD. Although the microservices architecture has strong potential for safety-critical cellular IoT systems, the desired level of availability is not achieved. Advanced availability mechanisms/architectures are required to achieve the desired level of availability for safety-critical cellular IoT systems.

The Network Function Virtualization (NFV) framework is an enabler for the automation of Network Service (NS) management. In the context of NFV, an NS is realized by interconnecting Virtual Network Functions (VNF) using Virtual Links (VL). Availability and continuity are among the important characteristics of an NS. These characteristics depend on the availability of the VNFs and VLs composing the NS, which are usually selected at NS design time. VNFs and VLs utilize the resources of the underlying infrastructure, and their availability (partially) depends on the availability of these resources. To design an NS to fulfill availability and continuity requirements, the availability required from the resources is constrained at design time. However, the characteristics of these resources may change at runtime due to the dynamicity of NFV infrastructure. Thus, impacting the availability of the VNFs and the VLs, which in turn may impact the availability and continuity of the NS. To fulfill these requirements at runtime despite the changes in the infrastructure, the NS should be adapted. In this paper, we propose a framework for the runtime adaptation of NSs that reacts to changes and adapts the NS configuration so that it can fulfill its availability and continuity requirements during the NS lifetime. We also propose a method to develop machine learning models that are used within the framework to determine the required adjustments at runtime. We implemented the proposed framework, the method for developing the machine learning models, a testbed, and NSs to assess the feasibility and validity of our approach through experiments.

Live testing is performed in the production environment. In such environment, test activities have to be orchestrated properly to avoid interferences with normal usage traffic. Conducting live testing activities manually is error prone because of the size and the complexity of the system as well as the required complex orchestration of different tasks. Furthermore, it would be impossible to react to failures and contain them in due time without automation. Live testing requires a high level of automation. This automation comes with several challenges especially in contexts such as cloud and zero touch networks because of the diversity of the software composing them. In this paper we discuss the challenges of automating live testing for cloud systems. We propose an architecture that relies on a modeling framework to decouple the specification of testing activities from the platforms needed to conduct them. We propose a solution for conducting testing activities on a live system according to such a specification.

Configurations play an important role in the behavior and operation of configurable systems. Prior to deployment a configured system is tested in the development environment. However, because of the differences between the development environment and the production environment, the configuration of the system needs to be adapted for the production environment. It is therefore important to re-test the configured system in the production environment. Since the system has already been tested in the development environment one should avoid reapplying all the test cases, it is desirable to reduce the test suite to be used in the production environment as much as possible. This is the goal of the method we propose in this paper. For this, we explore the similarities between the configuration used in the development environment and the configuration for the production environment to eliminate test cases. Indeed, the difference between the two configurations is only at the environment level, i.e. only the configuration parameters that influence the interactions between the system and its environment are changed for the deployment in the production environment. We propose a method that is based on a classification of the configuration parameters (based on their dependency to the environment) and use it to reduce the development time test suite before reapplying it in the production environment.

Kubernetes is an open source platform that hides the complexity of orchestrating containerized microservices while managing their availability. Stateless microservices can be executed in a resilient manner with Kubernetes. However, the same is not true for stateful microservices. Containers are characterized by having an ephemeral state and the state aspect of stateful microservices makes orchestration more complex than what the initial Kubernetes controllers were built for. In this paper, we investigate the current Kubernetes support for stateful microservices and identify the problems. We propose a solution to enrich Kubernetes with a State Controller that allows for state replication and automatic service redirection to the healthy entities through the management of secondary labels. We have conducted experiments under the default configuration of Kubernetes as well as under its most responsive one to evaluate our solution and compare the different architectures from an availability perspective. We also perform a comparative evaluation with OpenSAF, which is a proven solution for enabling high-availability. The results of our investigations show that our solution improves the recovery time of stateful microservices by 55% and even up to 99% in certain cases.

Microservices represent a new architectural style where small and loosely coupled modules can be developed and deployed independently to compose an application. This architectural style brings various benefits such as maintainability and flexibility in scaling and aims at decreasing downtime in case of failure or upgrade. One of the enablers is Kubernetes, an open source platform that provides mechanisms for deploying, maintaining, and scaling containerized applications across a cluster of hosts. Moreover, Kubernetes enables healing through failure recovery actions to improve the availability of applications. As our ultimate goal is to devise architectures to enable high availability (HA) with Kubernetes for microservice based applications, in this paper we examine the availability achievable through Kubernetes under its default configuration. We have conducted a set of experiments which show that the service outage can be significantly higher than expected.

Elasticity is a key feature of cloud systems. It allows service providers to adapt resource provisioning to workload changes without impacting the users. For this purpose, the system is periodically reconfigured according to workload variations using elasticity rules or policies. The challenge is to come up with those elasticity rules that efficiently provision resources to handle the workload variations and meet the quality of service expressed in the Service Level Agreements (SLAs). The definition of such elasticity rules is a challenging task. In this paper, we propose the generation of the elasticity rules automatically at system configuration design time, i.e. offline. We propose a model based approach that generates automatically these elasticity rules using the information acquired from the dimensioning and configuration of the system.

Domain-specific modelling with domain-specific languages (DSL) is rapidly gaining popularity in both research and industry for representing models of a target domain. However for a broader adoption, MDE tools need to provide adequate support for building these DSLs as well as for using the DSLs.

A Virtualized Network Function (VNF) is deployed as a cluster of VMs in the Network Functions Virtualization Infrastructure (NFVI). As in traditional telecom, VNFs are expected to provide the required functions at the requested level of availability. For this, one has to incorporate proper redundancy, and appropriate recovery and coordination mechanisms among the redundant entities. The Service Availability Forum (SA Forum) has standardized such mechanisms into a set of middleware services. Among them, the Availability Management Framework (AMF) has the responsibility of managing the availability of application services based on a configuration, called AMF configuration. We propose the use of AMF to manage the availability of the services provided by VNFs. For this, we map the AMF concepts to the Network Function Virtualization (NFV) domain and propose a method for the generation of AMF configurations for AMF managed VNFs. The approach generates an AMF configuration that meets the required level of availability of the requested service workload while aims at maximizing the resource utilization.

Cloud systems are upgraded regularly to improve their performance, fix bugs, deploy new software versions, etc. Their hosted services, for example, telecommunication services, may have stringent non-functional requirements such that they do not tolerate more than five minutes of downtime in a year regardless whether they are provided by a cloud system or the outage is due to an upgrade. Such services must remain highly available under any circumstance, which imposes availability requirements on the provider cloud system. The dynamicity of the environment is one of the main challenges for maintaining High Availability (HA) in cloud deployments during upgrades. To maintain availability during upgrades, most cloud providers use rolling upgrade, and to avoid any unexpected interference between the upgrade process and the cloud's scaling mechanism, scaling is disabled for the time of the upgrade. In this paper, we propose a novel approach for rolling upgrades applicable to - among others - IaaS cloud systems to address HA. This approach mitigates the interference between the upgrade process, any failure handling and scaling by dynamically adjusting the upgrade process to the changes in the cloud environment. Accordingly, the upgrade process can start/resume only when the system has sufficient resources to perform an upgrade iteration and suspends the process when this is not the case. As a result, scaling does not need to be disabled during upgrades, rather the scaling operations regulate the pace of the upgrade.

Recently, the paradigm of Network Functions Virtualisation (NFV) has emerged for the rapid provisioning and management of network services. It is based on the cloud paradigm and the virtualisation technology. The European Telecommunications Standards Institute (ETSI) has been actively defining the NFV framework, which includes several functional blocks for network service provisioning and management. The interfaces and the roles of these functional blocks are being defined as well as the artifacts they manipulate. However, the workflow defining the relations and dependencies between these different blocks as well as the successive processing of the artifacts throughout this workflow have not been specified. This is the purpose of this paper where we define an NFV standard compliant process for network service design and deployment. The process starts from the tenant network service requirements all the way to the network service deployment.

A system configuration is a set of configuration entities, their relations and the rules the system should obey. At runtime the configuration may be modified to meet new requirements, in response to performance degradations, or due to upgrade. Such modifications should maintain the consistency of the configuration to avoid any malfunction and service outage. Thus there is a need for runtime validation, which checks the modifications against the consistency rules of the system. This runtime validation should not only check the correctness of the modifications w.r.t. The consistency rules but it should also impose a minimal overhead especially in case of real-time and highly available systems. In this paper we introduce a partial validation approach for checking the system configuration consistency at runtime. Our approach is model based and uses UML profiles and OCL constraints.

Cloud computing is a popular paradigm for providing computational services. Cloud computing frameworks offer cost efficiency, better resource utilization and scalability. Availability remains as one of the main challenges for the cloud. Solutions, such as Heat, have been proposed and integrated with cloud controllers like Open Stack. These solutions protect services against application and infrastructure failure. However, the recovery for the application is tied to recovery of the underlying infrastructure, therefore, the service recovery and outage time may be substantial. In this paper we propose an architecture which integrates an existing middleware solution for high availability, OpenSAF, with OpenStack, for the management of the availability of the applications and the infrastructure. We show that in comparison with Heat, the proposed solution improves the service recovery and outage time and offers flexibility in terms of redundancy models and recovery actions.

The design of configurations for high availability management is a complex and error prone task. Automation of the process is a first step towards improving the quality of such configurations and for exploring the different potential solutions for a given set of requirements. An automated approach for configuration generation for applications deployed on top of the Service Availability Forum (SAForum) middleware has been proposed in the literature. This approach, however, may generate several configurations among which some may not meet the required level of service availability. Therefore, these configurations need to be analyzed to select one for the deployment. This is a complex process as many configurations may be generated and considered throughout the process. In this paper, we propose to enhance this configuration generation approach with a method to eliminate early in the generation process some configurations that cannot meet the service availability requirement. The method estimates the service availability for the different possible combinations of software components, which can provide the requested services, taking into account the properties of these components and the behaviour of the SAForum middleware.

Cloud services are becoming one of the most popular means of delivering computational services to users who demand services with higher availability. Virtualization is one of the key enablers of the cloud infrastructure. Availability of the virtual machines along with the availability of the hosted software components are the fundamental ingredients for achieving highly available services in the cloud. There are some availability solutions introduced by virtualization vendors like VMware HA and VMware FT. At the same time the SAForum specifications and OpenSAF as a compliant implementation offer a standard based open solution for service high availability. In this paper, we investigate these solutions for availability through experiments, compare them according to metrics and based on the results propose architectures that combine them to provide highly available applications in virtualized environments.

Over the last decade several model merging approaches have been proposed. Most of these approaches focused on version control systems. We are interested in merging test models. We present a merging approach to reconcile unit test models and generate integration test models using the UML Testing Profile.

Disaster response systems improve the situational awareness of responders and assist them by providing a wide range of services including communications, sensing/actuating and data collection and processing. The services are hosted on various types of devices such as laptops, PDAs, sensors and actuators that usually are interconnected through a mobile ad-hoc network (MANET). Interactions are required between these various services and this makes service discovery a key component of disaster relief systems. In this paper we propose a novel DNS-based service discovery architecture for disaster response systems. Our architecture employs the recent IETF proposal, DNS-based Service Discovery (DNS-SD) for representing service information as DNS records, and uses a cluster-based approach to dynamically form service directories and to enable service discovery.

SUMMARY The need for highly available services is ever increasing in various domains ranging from mission‐critical systems to transaction‐based ones such as banking. The Service Availability Forum has defined a set of services and related API specifications to address the growing need of commercial off‐the‐shelf high availability solutions. Among these services, the availability management framework (AMF) is the service responsible for managing the high availability of the application services by coordinating redundant application components deployed on the AMF cluster. To achieve this task, an AMF implementation requires a specific logical view of the organization of the application's services and components, known as an AMF configuration. Developing manually such a configuration is a complex error‐prone task that requires extensive domain knowledge. In this paper, we present an approach for the automatic generation of AMF configurations and alleviate the task of configuration designers. One important aspect of the AMF configuration is ranking the service units, when it is required by the redundancy model, for the assignment of the workload by AMF at runtime. Our approach includes a technique for generating these rankings in such a way that guarantees load balancing even after the occurrence of a failure. Copyright © 2012 John Wiley & Sons, Ltd.

User Interface (UI) development methods are poorly integrated with standard software engineering practice. The differences in terms of artifacts involved, development philosophies, and lifecycles can often result in inconsistent system and UI specifications leading to duplication of effort and increased maintenance costs. To address such shortcomings, we propose an integrated development methodology for use case and task models. Use cases are generally used to capture functional requirements whereas task models specify the detailed user interactions with the UI. Our methodology can assist practitioners in developing software processes which allow these two kinds of artifacts to be developed in a codependent and integrated manner. We present our methodology, describe its semantic foundations along with a set of formal conformance relations, and introduce an automated verification tool.

Open Mobile Alliance (OMA) RESTful location services are standard RESTful Web services for terminal location. They are location technology-independent and enable applications' portability and interoperability. Wireless sensors are electronic devices that can sense context: space, environment and physiology. Location is a key element of space context information. Wireless sensors can sense location with an accuracy that most other technologies cannot provide, which has made them the technology of choice for several applications. This paper proposes a novel architecture for the implementation of OMA RESTful location services in wireless sensor environments. The architectural components and operational procedures are described. The proof of concept prototype is also described, along with the measurements.

In today's information based world the demand on highly available services is ever increasing. Fault tolerant systems are capable of providing the expected services even in the presence of a failure. This is achieved through the redundancy of the service providers, where service assignments i.e. workloads are shifted to redundant healthy service providers when a failure occurs. The assignment and the shift are performed according to a redundancy model. A well-known redundancy model is the N+M where we have N active service providers and M standbys. In case of a failure of an active provider, the services are reassigned to its standbys. Maintaining a balanced workload before and after a failure in the N+M redundancy is a challenging task. Especially when the solution is decided at configuration time, and no runtime information is available. This is exactly the issue we tackle in this paper. We present three different approaches aiming at solving this problem with different priorities of the relevant constraints. Our solutions do not require any runtime information and can maintain a balanced workload even after a failure by anticipating the workload redistribution.

Highly available services are nowadays provided by large and complex systems built from Commercial-Of-The-Shelf (COTS) components. Such systems are deployed on top of standardized middleware services that manage service availability by monitoring the component health and by dynamically shifting workload from a faulty component to a healthy one. This management is achieved through the usage of a configuration model. Characterizing the availability of such systems before deployment is an important question. Indeed, components may be characterized with a failure rate, but this information does not translate directly to service failure/outage which is the first step towards service availability evaluation. In this paper, we propose an approach to derive from the component failure rates the recovery duration and service outage while taking into account the configuration characteristics and middleware service recovery procedures.

Abstract Use case models are the specification medium of choice for functional requirements, while task models are employed to capture User Interface (UI) requirements and design information. In current practice, both entities are treated independently and are often developed by different teams, which have their own philosophies and lifecycles. This lack of integration is problematic and often results in inconsistent functional and UI design specifications causing duplication of effort while increasing the maintenance overhead. To address these shortcomings, we propose a formal semantic framework for the integrated development of use case and task models. The semantic mapping is defined in a two step manner from a particular use case or task model notation to the common semantic domain of sets of partially ordered sets . This two-step mapping results in a semantic framework that can be more easily reused and extended. The intermediate semantic domains have been carefully chosen by taking into consideration the intrinsic characteristics of use case and task models. As a concrete example, we provide a semantics for our own DSRG use case formalism and an extended version of ConcurTaskTrees, one of the most popular task model notations. Furthermore, we use the common semantic model to formally define a set of refinement relations for use case and task models.

User interface (UI) development methods are poorly integrated with standard software engineering (SE) practices. Despite current efforts of closing the conceptual gap between these two disciplines, there is still a lack of methodologies supporting a collaborative and synchronized development approach. To address this shortcoming, we propose an integrated development methodology for use cases and task models. Use cases have become the standard to model functional requirements, whereas task models are used to specify UI requirements. Based on this understanding we propose using CTT task models to incrementally enrich the UI-related steps in the use case model, thus achieving a clear separation of concerns and avoiding potential inconsistencies between the two artifacts.

Black box testing focuses on the core functionality of the system, while user interface testing is concerned with details of user interactions. Functional and user interface test cases are usually generated from two distinct system models, one for the functionality and one for the user interface. As a result, test cases derived from either model capture only partial system behavior and as such, are inadequate for testing full system behavior. We propose a method for formally integrating the model for the system functionality and the model for the user interface. The resulting composite model is then used to generate more complete test cases, capturing detailed user interactions as well as secondary system interactions. In this paper we employ use cases for modeling system functionality, and task models for describing user interfaces.

Wireless actuators are small scale devices that can receive/accept instructions and act on their environment. The IP Multimedia Subsystem (IMS) is a key component for 3G networks. It aims at seamless provisioning of multimedia services. Combining actuation capabilities with IMS capabilities will certainly enable novel value added services. This paper proposes an architecture for the integration of wireless actuation with IMS. The cornerstone of the architecture is the actuation control function, a new functional entity that we introduce into the IMS architecture. A proof of concept prototype has also been developed along with an application to demonstrate the potential of such an integration.

The service availability forum (SAF) has defined a set of service API specifications addressing the growing need of commercial-off-the-shelf high availability solutions. Among these services, the availability management framework (AMF) is the service responsible for managing the high availability of the application services by coordinating redundant application components. To achieve this task, an AMF implementation requires a specific logical view of the organization of the application's services and components known as an AMF configuration. Developing manually such a configuration is a complex, error prone, and time consuming task. In this paper, we present an approach for automatic generation of AMF configurations from a set of requirements given by the configuration designer and the description of the software as provided by the vendor. Our approach alleviates the need of configuration designers dealing with a large number of AMF entities and their relations.

The Availability Management Framework (AMF) is a service responsible for managing the availability of services provided by applications that run under its control. Standardized by the Service Availability Forum (SAF), AMF requires for its operations a complete and compliant AMF configuration of the applications to be managed. In this paper, we describe two complementary and integrated tools for AMF configurations generation and validation. Indeed, writing manually an AMF configuration is a tedious and error prone task as a large number of requirements defined in the standard have to be taken into consideration during the process. One solution for ensuring compliance with the standard is the validation of the configurations against all the AMF requirements. For this, we have designed and implemented a domain model for AMF configurations and use it as a basis for an AMF configuration validator. To further ease the task of a configuration designer, we have devised and implemented a method for generating automatically AMF configurations.

The IP Multimedia Subsystem (IMS) is becoming the de-facto standard for IP-based multimedia services, while Wireless Sensor Networks (WSNs) are gaining a lot of popularity due to their ability of capturing a rich set of contextual information and their high application potential. Making the rich set of contextual information, captured by WSNs, available to the IMS can greatly enhance its service provisioning capabilities and open the door to a wide range of novel multimedia services. We have previously proposed a solution for WSNs/IMS integration. One of the key components of this solution is a WSN/IMS gateway acting as intermediary between the two networks. This paper focuses on the design and implementation of this gateway. The gateway architecture proposed encompasses the information management and support functions needed to enable IMS interaction with different types of WSNs. A prototype of this architecture is built and tested using Ericsson's IMS simulated environment. Furthermore, two applications (a pervasive game and a personalized call control application) are used to demonstrate the system operation.

Mobile ad hoc networks (MANETs) are infrastructure-less and can be set up anywhere, anytime. They can host a wide range of applications in rescue operations, military, private, and commercial settings. Multimedia conferencing is the basis of a wealth of "killerrdquo applications that can be deployed in MANETs. Some examples are audio/video conferencing, multiplayer games, and online public debating. Signaling is the nerve center of multimedia conferences-it establishes, modifies, and tears down conferences. This paper focuses on signaling for multimedia conferences in MANETs. We review the state of the art and propose a novel architecture based on application-level clusters. Our validation employed SIP as the implementation technology and OPNET as our simulation tool. Our clusters are constructed dynamically and the nodes that act as cluster heads are elected based on their capabilities. The capabilities are published and discovered using a simple application-level protocol. The architectural principles and the clustering operations are discussed. Our SIP-based implementation is also presented along with the performance evaluation.

Web services can be reused to create new ones using composition methods. We have proposed a framework for Web services composition previously. In this framework, we describe Web services with functional, semantic, behavioral, and non-functional characteristics. The framework uses different techniques for creating the composite service. We have already proposed a matchmaking technique that enables discovering the primitive Web services that would be used to create the composite service. In this paper, we propose concepts and schemes for categorizing and assembling the matched services. A core concept called categories is used by the proposed techniques, which are basically organizational elements. The categorization technique helps the assembly technique in creating the composite service by categorizing the matched services. The assembly technique manipulates and selects the categorized services from different categories, uses BPEL to orchestrate the selected services, and finally selects the best-assembled service as the composed service. A case study from telecom domain is used to illustrate the proposed techniques.

Emergency services represent one of the fundamental services offered by the IP multimedia subsystem (IMS). Currently, these services rely on a limited range of contextual information (mainly location). A richer set of contextual information could be exploited to provide enhanced emergency services and lead to more efficient emergency operations. In this paper, we propose an extension of the 3GPP IMS emergency service architecture for the provision of enhanced, context-aware emergency services. The 3GPP presence framework is leveraged and extended to realize the information management aspects of the architecture. Furthermore, a proof-of-concept prototype, showcasing an enhanced emergency service scenario, is presented.

Wireless Sensor Networks (WSN) are made up of small devices that can sense context information (e.g. space, physiology, and environment). The IP Multimedia System (IMS) aims at the convergence of Internet and cellular networks. It enables the delivery of multimedia services to end-users. Integrating the sensing capabilities of WSN in the IP multimedia subsystem will open the door to a wide range of novel multimedia services. This paper proposes a presence based architecture for the integration, focusing on how the information is conveyed from the WSN to the presence infrastructure (i.e the inbound interface). Presence is an integral part of IMS. It enables the distribution of end-user presence information (e.g. location, availability), a sub-set of context information, to interested parties, generally applications. We introduce the architecture and elaborate some of the required extensions to the 3GPP presence service. The proof of concept prototype is also described.

Ambient networks refer to a new networking concept for beyond 3G. They use automatic network composition to enable dynamic and instantaneous inter- working between heterogeneous networks on demand. Ambient networks can host several registries (e.g. management information bases, context information bases). When they autonomously compose, the hosted registries have to follow suit and compose. This paper focuses on the issues related to the autonomous composition of registries when ambient networks compose. We identify a set of requirements and propose a general architecture for autonomic composition. We also discuss cursorily information discovery after composition.

A critical challenge in mobile ad hoc networks is to scale with a flat structure. Clusters are customarily used at the network layer of these networks, especially for the routing schemes required to approach this problem. Recently, their use at the application layer has also been proposed. However, this new usage faces many performance challenges. This paper focuses on how to optimize the performance of cluster-based application layer schemes in mobile ad hoc networks. It proposes an architecture based on cross-layer design, a concept employed more and more in wireless environments, and which violates reference-layered architecture. We illustrate this architecture with a case study on a cluster-based session signaling scheme. We also present a proof-of-concept prototype and our initial measurements.

In conventional wireless sensor networks, sinks collect data from sensors and/or aggregators and interact with end-user applications via centralized gateways. However, there exist application scenarios where this modus operandi may not be suitable. In such cases it is preferable that the applications interact directly with the sensors. This paper proposes a Web- service based architecture with an overlaid UDDI for these cases. It also presents simulation results for these scenarios to demonstrate performance gains.

It is foreseen that several wireless sensor networks (WSNs) will be deployed in the very near future to provide various sensing services to end user applications. A wide range of novel end-user applications will emerge. In some application scenarios, the sinkless model is appropriate. In this model, the applications interact directly with the sensor nodes, without going through a gateway. However, the current sensor nodes use proprietary protocols and data access frameworks. This propriety will hinder the speed of evolution of applications. There is a need for a framework that is well known to application developers and is based on standard protocols. This paper presents an embedded Web services platform residing on the sensor nodes, allowing direct interaction between applications and individual sensor nodes. The lessons learned indicate that Web service platform on sensor node is feasible, despite the nodes' limited resources and the complexity of the framework.

UML can be effectively used for the design and analysis of real-time systems. UML profiles for real-time, like the current OMG's standard UML/SPT, enable the modeling of quantitative requirements such as time constraints as well as behavioral features such as concurrency. Because of the multitude of diagrams and their complexity, UML/SPT models face the challenging issue of consistency. In this paper, we look into the behavioral consistency and particularly into concurrency-related properties of UML/SPT models. In order to do so, we formally define the UML/SPT concurrency domain model in terms of timed automata. As a straightforward application of this semantics, UML/SPT concurrent models can be validated using well-established model checking techniques and tools

Conferencing represents an important category of applications, which includes videoconferences and distance learning. To our knowledge, there is no signaling architecture for conferencing in integrated 3G/mobile ad hoc networks. However, there are architectures for conferencing in stand alone 3G and in stand alone mobile ad hoc networks. Unfortunately, none are suitable when the two networks are integrated. This paper proposes a novel signaling architecture for conferencing in integrated 3G/mobile ad hoc networks. This architecture is based on application-level clusters and conference gateways. The gateways mediate between the 3G and the mobile ad hoc networks. We have implemented a prototype using the Session Initiation Protocol as our technology.

Applications are the ultimate consumers of the information collected by sensors. There exist several frameworks for the interactions between end-user applications and sensors. They range from low-level APIs to databases and include Web Services. This paper is devoted to the use of Web Services for bridging end-user applications and wireless sensors networks. Its first contribution is a systematic evaluation of the current frameworks for the interactions between end-user applications and wireless sensors networks. The evaluation shows the potential of Web Services, compared to the other frameworks and motivates their usage in the case study. The second contribution is the definition of Web Services for the I-centric telecommunication services, and their implementation in a wireless sensor network that does not support Web Services. We demonstrate that Web Services are very promising as "bridges" and share the lessons we have learned.

UML through its profiling mechanism is well adapted for the modeling of real-time software requirements and designs. It is becoming the de facto standard. On the other hand, several real-time schedulability analysis techniques have been proposed in the literature. One of the current research challenges is in bridging the gap between the UML/SPT models and the well-established real-time schedulability analysis techniques. In this paper, we propose an MDA-compliant approach addressing this issue. We develop an UML metamodel for a well-established schedulability analysis technique. We propose a rule-based transformation between the UML/SPT schedulability analysis sub-profile metamodel and this metamodel. We illustrate our approach with an example

Presence technology conveys the willingness and ability of an entity to communicate and is very useful in developing innovative applications. Protocols and APIs have been proposed for presence, but these APIs are at a low level of abstraction. Web services provide the flexibility to develop loosely coupled applications with coarse-grained interfaces. This paper proposes a novel Web service for presence application development. This Web service is presence protocol independent and its use is illustrated in the paper by a concrete application. We have implemented it as a gateway towards an IETF SIMPLE based presence server, but other implementations are possible. The mapping is discussed and the prototype described. Performance measurements are also made. The results indicate that the additional overhead introduced because of XML based SOAP messages is not prohibitive, although significant.

Value added services, or more simply - services, are the critical ingredient for the success and the survival of Internet Telephony. Services can be defined as anything that goes beyond two party voice calls. Some examples are multiparty gaming, customized stock quotes and call screening. This paper focuses on service creation in Internet Telephony. Service creation plays a major role in Internet Telephony because it enables openness and programmability by offering frameworks for the development of value added services. Two principal sets of standards have emerged for Internet Telephony: H.323 from the ITU-T and SIP from the IETF. No service creation framework comes with the H.323 set. Two frameworks come with the SIP set: the Call Processing Language (CPL) and the SIP common gateway interface (CGI). Besides the IETF, other forums such as Parlay and JAIN have proposed pertinent frameworks. The first part of the paper provides an overview of the service creation frameworks for Internet Telephony. A common characteristic of these frameworks is that they require knowledge that nonexperts may not have (e.g., scripts, programming languages). High-level service creation environments may help these nonexperts. The second part of the paper presents a case study on a high level service creation environment (SCE) where pre-defined graphical components are combined into services. The environment is discussed in detail along with the service logic execution environment (SLEE) where the services are executed. The SCE and SLEE make no assumption on the service creation framework supported by the network, and any of the standard frameworks could be used provided it offers the functionality abstracted in the graphical components. We have used the Parlay APIs as a framework and the prototype is built for a SIP environment. The prototype is described and the lessons we have learned are presented.

UML and MSC are widely used by software practitioners. SDL is an ITU standard language for telecommunications software specification. It has a formal semantics, and is supported by several commercial tools, which allow for simulation and validation of SDL design specifications as well as automatic code generation from these specifications. In order to take advantages of the SDL available tools and still use the very popular notations such as UML and MSC, we have developed an approach for specifying distributed systems in UML and MSC. MSCs are used to specify the behavior (scenarios) of the distributed system under consideration. UML, more precisely Class Diagrams and Object Diagrams, are used to specify the architecture of the system. By architecture, we mean the different components of the system and their interconnections. The MSC and UML specifications are translated automatically into a full SDL specification. We introduce our distributed system specification style in UML and its automatic translation into an SDL architecture.

Software systems evolve because user requirements change over time. Maintaining software systems is a challenge, especially when the old behavior has to be preserved while new functionality is added. In this paper, we extend the transformational model to the maintenance phase and call it extended transformational model. Using this extended transformational model, we develop an approach to maintain SDL (Specification and Description Language) specifications. This approach consists of enriching, in three phases, SDL specifications with new behaviors specified with another formal language, MSC (Message Sequence Charts). The approach is based on a formally defined enrichment relation that must hold between the old and the new SDL specifications.

Real-time systems interact with their environment using time constrained input/output signals. Examples of real-time systems include patient monitoring systems, air traffic control systems, and telecommunication systems. For such systems, a functional misbehavior or a deviation from the specified time constraints may have catastrophic consequences. Therefore, ensuring the correctness of real-time systems becomes necessary. Two different techniques are usually used to cope with the correctness of a software system prior to its deployment, namely, verification and testing. In this paper, we address the issue of testing real-time software systems specified as a timed input output automaton (TIOA). TIOA is a variant of timed automaton. We introduce the syntax and semantics of TIOA. We present the potential faults that can be encountered in a timed system implementation. We study these different faults based on TIOA model and look at their effects on the execution of the system using the region graph. We present a method for generating timed test cases. This method is based on a state characterization technique and consists of the following three steps: First, we sample the region graph using a suitable granularity, in order to construct a subautomaton easily testable, called grid automaton. Then, we transform the grid automaton into a nondeterministic timed finite state machine (NTFSM). Finally, we adapt the generalized Wp-method to generate timed test cases from NTFSM. We assess the fault coverage of our test cases generation method and prove its ability to detect all the possible faults. Throughout the paper, we use examples to illustrate the various concepts and techniques used in our approach.

Nowadays, there exist a wide variety of verification tools. Some, like the SPIN model checker, are designed and mainly used for the verification of interleaving software systems, such as communication protocols. Others, like VIS (Verification Interacting with Synthesis), are designed and used for synchronous hardware systems verification. In this paper, we compare and contrast SPIN and VIS. In particular, we devote a special attention to the efficiency of these tools for the verification of communications protocols that can be implemented either in software or hardware. As a basis of our comparison, we formally describe and verify the ATMR (Asynchronous Transfer Mode Ring) medium access protocol using SPIN, and its hardware implementation using VIS. We believe that this study is of particular interest, as more and more protocols, like the ATM protocol stack, are being implemented in hardware in order to match high speed requirements. However, this is not a formal comparison of SPIN and VIS.

A new pragmatic approach for feature interaction (FI) detection for intelligent networks (IN) is presented in this paper. In this approach, the causes of FI given in Bellcore and European benchmarks serve as the starting point. The necessary information for feature description is derived from these causes. This information is modelled using an object-oriented template. Features are described in terms of necessary resources and actions. The detection algorithm takes this information as input and checks for interactions between features. The algorithm consists of three parts: filtering, feature instantiation and detection. Using the filtering method, all the possible interaction-prone scenarios are produced and using the list of topologically different call combinations the actual features are instantiated. The detection algorithm is run on these actual participants of the features in order to detect interactions. We applied our approach to the feature interaction benchmarks.

A framework is developed in order to support the development of a family of applications. Many approaches to documenting frameworks have been tried though with different aims and audiences in mind. Of greatest utility are those aimed at reducing the learning curve for application developers. We propose the concept of a reuse case as offering a perspective of the different approaches to documenting frameworks. The categories of reuse cases are defined, and we discuss other views of reuse cases that can help to classify them.

Real time reactive systems interact with their environment, using inputs and outputs, within specified time constraints. For such systems, a functional misbehavior or a deviation from the specified time constraints may have catastrophic consequences. Therefore, ensuring the correctness of real time systems becomes very important. We introduce the potential faults which can be encountered in a timed system implementation. We adapt an existing test cases generation technique, based on state characterization set, to generate timed test cases from a timed system specification. We model a timed system with a Timed Input Output Automaton (TIOA), which is a variant of the Alur and Dill model (R. Alur and D. Dill, 1994). In order to generate the timed test suite, the TIOA is first transformed into a Nondeterministic Timed Finite State Machine (NTFSM) with a given granularity. We illustrate our method with an example.

The use case concept is a tool for capturing the requirements of a system. A single use case describes a subset of a system's functionality in terms of the interactions between the system and a set of users or actors. A use case is initiated by a particular user, and serves the purpose of delivering some meaningful unit of work, service, or value to the initiator. When capturing requirements, a use case views the system as a black box. Due to their popularity, the concept of use cases has been abused to some extent, and been applied to specifying the "requirements" of all sorts of things, such as those of a subsystem of the system architecture. Cockburn (1997) acknowledges 18 different definitions of use cases. This has created a great deal of confusion and a need for clear definitions. Just what is a "use case"? We seek to answer that question, by providing a specification of a use case and its related concepts using the Z formalism.

A method for the selection of appropriate test case, an important issue for conformance testing of protocol implementations as well as software engineering, is presented. Called the partial W-method, it is shown to have general applicability, full fault-detection power, and yields shorter test suites than the W-method. Various other issues that have an impact on the selection of a suitable test suite including the consideration of interaction parameters, various test architectures for protocol testing and the fact that many specifications do not satisfy the assumptions made by most test selection methods (such as complete definition, a correctly implemented reset function, a limited number of states in the implementation, and determinism), are discussed.>

Previous papers describe an algorithm for deriving a specification of protocol entities from a given service specification. A service specification defines a particular ordering for the execution of service primitives at the different service access points using operators for sequential, parallel and alternative executions. The derived protocol entities ensure the correct ordering by exchanging appropriate synchronization messages, between one another through the underlying communication medium.