Rosario Giunta

Providing QoS strategies and cloud-integration to web servers by means of aspects

The main responsibilities of a web server are to listen from the communication channel and to prepare replies to requests. Additional responsibilities include adapting processing activities, for example, through scheduling or request filtering, so as to satisfy Quality of Service (QoS) requirements. Typical QoS‐related concerns address behavioural constraints (e.g. response time bounds, satisfiable by scheduling the most urgent requests first) and resource monitoring, for optimal use. Although such concerns are spread across several web server components, they should be handled separately from communication‐related ones, for the sake of modularity.

AODP: refactoring code to provide advanced aspect-oriented modularization of design patterns

Although solutions provided by design patterns are an invaluable resource for developers, some design patterns lead to placing code addressing design pattern concerns into the same class as application code. This weakens the modularity of an application because it makes classes more complex, more prone to changes and less reusable. In order to avoid the tangling of design pattern- and application-related code within classes, this paper proposes an approach for assisting the refactoring of an application that uses design patterns into an aspect-based version. This allows application classes, and aspects implementing design patterns, to stay independent of each other, thus greatly enhancing modularity. Developers intending to change the role of an application class need only update the code connecting it to the design pattern involved.

Aspects and Annotations for Controlling the Roles Application Classes Play for Design Patterns

Design patterns are an invaluable resource for developers. Yet, for some of them the implementation of an application concern and the code needed to enforce the design pattern solution can be tangled within the same class. This potent ially makes classes more complex, more prone to changes and less reusable. In order to keep the complexity of classes under manageable levels, this paper proposes a solution based on aspect-orientation. Our solution makes aspects and application classes independent of each other, while connecting code is used to concisely express the role played by classes within design patterns. Developers needing to modify the role of an application class should only update such connecting code, thus keeping changes to application code to a minimum. The performance overhead of such an approach is evaluated and compared with the standard implementation.

Superimposing roles for design patterns into application classes by means of aspects

Application classes participating as a role in some design patterns often implement both pattern- and application-related concerns. This tangling potentially makes classes more complex, more prone to changes and less reusable. This paper proposes an aspect-oriented solution that makes classes free of pattern-related code, whereas a connecting code concisely maps roles into classes. Developers having to modify the role of a class need only update such a connecting code, thus reducing changes to application code.

Kaqudai: A Dependable Web Infrastructure Made Out of Existing Components

An internet application typically consists of a business logic complemented by additional concerns, such as communication, security and higher level features such as dependability. We advocate the use of aspect orientation as an advanced concern separation technology, ensuring higher modularity and reusability of code. In this paper we show how such an approach can be put into practice, by enhancing an existing web application with a dependability layer, addressing availability, reliability and data integrity concerns. Specifically, we have produced a set of aspects and other suitable components which can be smoothly integrated into an existing web server, endowing it with the ability to redirect service requests under excessive load. Redirection may target either cloud-powered lightweight replicas of the main web server, or publicly exposed browsing caches from clients. Experiments were conducted on the W3C Jigsaw web server.

Augmenting a Web Server with QoS by Means of an Aspect-Oriented Architecture

The handling of Quality of Service (QoS) parameters on a web server is a concern that generally spreads across the several modules responsible for fetching and delivering contents as per incoming requests. In order to avoid tangling between QoS and communication-related concerns, this paper proposes the use of aspect-orientation to handle QoS on top of an existing web server, Jigsaw. We show how an aspect-based architecture can be effective for providing the web server with several improvements when processing incoming requests. QoS parameters have been handled by associating requests with priorities and by introducing into the web server checks on resource-usage and tasks to be executed. Suggested aspects are connected at compile-time to existing classes, hence keeping the QoS-enforcing code separated from web server modules.

Using aspects and annotations to separate application code from design patterns

Design patterns are an invaluable resource to generate effective design solutions. However, employing some of them can be cumbersome for some application classes when these are forced to mix domain- with pattern-related code. Indeed, for a number of design patterns, we view the code implementing the behaviour required by their roles as a snippet, or concern, which is not involved in the domain issues that a class is supposed to address. This paper proposes a methodology to obtain the behaviour described by some well-known design patterns, which allows better separation between domain and non-domain concerns through recourse to aspects and annotations. Indeed, application classes retain all the benefits that the design patterns are supposed to give them, while staying thoroughly separated from non-domain concerns. Moreover, fewer lines of code are needed to obtain a design pattern than in other approaches, and the propagation of changes to application code, caused by the introduction or removal of a design pattern, are greatly reduced.

Testing Replica Selection Policies in a Pan-European Grid VO

In a typical grid environment, replicas are spread over storage hosts, so as to increase availability and reduce files transfer times. Generally, the grid middleware lets users choose the storage host that will be serving the replica. However, having users able to choose could adversely affect network conditions and increase transfer times. This paper proposes two replica selection policies that choose one among the storage hosts holding a requested replica. The selection policies try to minimise file transfer time by extracting the least loaded host or the closest among unloaded hosts. It is shown that overall performances for transferring replicas depend on network topology, latency and bandwidth of links, and load of storage hosts and links.

Handling Replica Management Concerns by Means of Aspects

In order to balance the load of grid resources, often applications deployed on the grid environment need to determine and take decisions on the basis of the dynamic state of these resources. This knowledge makes application run smoothly, however it also makes applications more complex. In this paper we propose to use aspect-orientation to handle concerns related with the state of resources on a grid, i.e. hosts holding files. Aspects are used to redirect selected invocations to grid middleware Globus and execute additional code that determines the most appropriate hosts to be accessed. Needed aspects are generated for the application at hand and according to the desired feature given as a configuration file.

A Redundancy-Based Attack Detection Technique for Java Card Bytecode

A Java Card Virtual Machine applet running on smart cards may be subject to tampering. We protect existing applets by encoding additional lists representing specific instructions which may be the targets of a variety of attacks. The lists are specifically encoded to be a viable solution in limited smart cards hardware. Our modified virtual machine before executing a fetched instruction checks the lists to verify that it has not been modified, blocking the execution if a modification is detected.