Nico Janssens

Support for distributed adaptations in aspect-oriented middleware

Many aspect-oriented middleware platforms support run-time aspect weaving, but do not support coordinating distributed changes to a set of aspects at run-time. A distributed change entails weaving or unweaving multiple inter-dependent aspects that are logically or physically distributed. Coordinating such multiple weavings inside the application layer is a complex and difficult task for the application developer, because global state consistency, structural integrity and other safety properties have to be preserved. In this paper, we present the DyReS framework that offers the required coordination support on top of existing aspect-oriented middleware platforms. The framework is customizable towards application-specific requirements to achieve improved performance and reconfiguration semantics. We have validated our approach by delivering and examining two implementations of the DyReS framework: one on top of JBoss AOP and a second one for Spring AOP.

Self-adapting concurrency: the DMonA architecture

A major problem in todays Internet servers is that they suffer from extreme peak loads. Traditional (operating) systems are designed to perform extremely well under heavy load conditions. However, it is not feasible to over-provision resources only to support peak loads. A key factor to deal with such peak loads is internal concurrency control. We have developed a component based architecture (DMonA), which allows to adapt internal concurrency according to measured throughput. Performance tests show that DMonA outperforms traditional approaches, while it is still very manageable thanks to the underlying DiPS component architecture.

An agent design method promoting separation between computation and coordination

The development of (internet) agents is often a tedious and error-prone task resulting in poorly reusable designs, since both the internal computation of the agent as well as the coordination support are developed in an ad hoc fashion. To improve the process of agent-oriented software development, we propose an agent design method that imposes the separation of internal computation from coordination aspects. This method comprises two dimensions: a design formalism and an agent design process. As an illustration of the presented method, we present the design of an internet agent that is entitled to deploy a distributed service in a computer network, without breaking the consistency of that network. The presented design method has resulted in the development of ACF (Agent Composition Framework), a component framework to build flexible internet agents. We argue that the presented design method combined with this infrastructure can promote a modular and easy to manage approach to the design and development of internet agent applications.

NeCoMan: middleware for safe distributed service deployment in programmable networks

Recent evolution in computer networks clearly demonstrates a trend towards <i>complex</i> and <i>dynamic</i> networks. To fully exploit the potential of such heterogeneous and rapidly evolving networks, it is essential for the protocol stacks of the connected devices to adapt themselves at runtime as the environment changes in which they execute. This illustrates the need for employing <i>programmable</i> (i.e. adaptable) network nodes. In this paper, we concentrate on deploying <i>point-to-point based distributed services</i> in programmable protocol stacks. More in detail, we examine <i>safe runtime adaptations</i> of such services so as to preserve service consistency in programmable networks. This has resulted in the development of the NeCoMan (<i>Net</i>work <i>Con</i>sistency <i>Man</i>agement) middleware, a <i>generic distributed coordination platform</i> responsible for safe addition, replacement and removal of point-to-point services among programmable nodes. The novelty of this reflective middleware is in its ability to <i>improve the effectiveness</i> of the deployment process. This is achieved by customizing the deployment process depending on the properties of both the network service that will be deployed and the underlying execution environment.

NeCoMan: middleware for safe distributed-service adaptation in programmable networks

NeCoMan middleware customizes dynamic adaptation of point-to-point-based network services in programmable networks, taking into account the properties of the network services involved as well as the reconfiguration semantics. This article focuses on safe runtime adaptation of point-to-point-based network services in programmable networks. Many network services such as compression, fragmentation, reliability, and encryption conform to a point-to-point-based distributed-service model. This model represents a pair of tightly coupled components (not necessarily situated on neighboring nodes) that must cooperate to offer a distributed service. To prevent the runtime addition, replacement, or removal of these network services from jeopardizing a programmable networks correct functioning, the network programmer must coordinate the adaptation of the protocol stacks accommodating the service components.

A modular approach enforcing safe reconfiguration of producer-consumer applications

Unanticipated software adaptations are becoming increasingly important in the domain of distributed systems. Due to performance and availability requirements, these adaptations need to be enforced at run-time. However for dynamic changes to yield valid systems, a safe state for reconfiguration of the involved software modules must be enforced. This paper proposes a solution to modularize support for achieving safe reconfiguration and separate it from basic application functionality. In addition, we describe a mechanism to obtain a safe state for unanticipated reconfiguration of producer/consumer based systems, rather than being limited to updates of independent software components. The presented method imposes such a safe state with minimal interference to the rest of the system, and with minimal contribution from the programmer. We believe that a wide range of producer/consumer based systems can take advantage of the presented solution.

Adding dynamic reconfiguration support to JBoss AOP

The majority of aspect-oriented middlewares supporting dynamic aspect weaving fail to preserve important safety properties while weaving or unweaving a distributed aspect at runtime. This position paper looks in particular at the safety properties of structural integrity and global state consistency. Preserving these two safety properties in the presence of dynamic change has already been extensively addressed in the space of dynamic reconfiguration of component-based distributed systems. As will be argued in this position paper, existing coordination protocols developed in this space can be largely reused for distributed aspect weaving provided that some small adaptations are made to account for the aspect-oriented composition mechanisms. To demonstrate results and as a proof-of-concept, we describe how we have ported the NeCoMan dynamic reconfiguration support on top of the JBoss AOP framework. As a result, system-wide consistency can be preserved in JBoss when weaving or unweaving a distributed aspect at runtime.

Towards preserving correctness in self-managed software systems

Currently, paradigms such as component-based software development and service-oriented software architectures promote modularization of software systems into highly decoupled and reusable software components and services. In addition, to improve manageability and evolveability, software systems are extended with management capabilities and self-managed behavior. Because of their very nature, these self-managed software systems often are mission critical and highly available. In this paper, we focus on the complexity of preserving correctness in modularized self-managed systems. We discuss the importance of consistent software compositions in the context of self-managed systems, and the need for a correctness-preserving adaptation process. We also give a flavor of possible approaches for preserving correctness, and conclude with some remarks and open questions.

Connecting embedded devices using a component platform for adaptable protocol stacks

Research domains such as sensor networks, ad-hoc networks, and pervasive computing, clearly illustrate that computer networks have become more complex and dynamic. This complexity is mainly introduced by unpredictable and varying network link characteristics, heterogeneous capabilities of attached nodes, and the increasing user expectations regarding reliability and quality of service. In order to deal with this complexity and dynamism of computer networks, the system’s protocol stack must be able to adapt itself at runtime. Yet, to handle this complex challenge effectively and efficiently, we claim that it is essential for protocol stacks to be developed with run-time adaptability in mind. This chapter presents a software architecture tailored to build highly adaptable protocol stacks, along with a component platform that enforces this architecture. Although the presented software architecture focuses on protocol stacks in general, we zoom in on the application of its founding principles in the domain of embedded network devices.