966 research outputs found

    System Support for Managing Invalid Bindings

    Full text link
    Context-aware adaptation is a central aspect of pervasive computing applications, enabling them to adapt and perform tasks based on contextual information. One of the aspects of context-aware adaptation is reconfiguration in which bindings are created between application component and remote services in order to realize new behaviour in response to contextual information. Various research efforts provide reconfiguration support and allow the development of adaptive context-aware applications from high-level specifications, but don't consider failure conditions that might arise during execution of such applications, making bindings between application and remote services invalid. To this end, we propose and implement our design approach to reconfiguration to manage invalid bindings. The development and modification of adaptive context-aware applications is a complex task, and an issue of an invalidity of bindings further complicates development efforts. To reduce the development efforts, our approach provides an application-transparent solution where the issue of the invalidity of bindings is handled by our system, Policy-Based Contextual Reconfiguration and Adaptation (PCRA), not by an application developer. In this paper, we present and describe our approach to managing invalid bindings and compare it with other approaches to this problem. We also provide performance evaluation of our approach

    Aspect-Oriented Smart Proxies in Java RMI

    Get PDF
    Java's Remote Method Invocation (RMI) architecture allows distributed applications to be written in Java. Clients can communicate with a server via a local proxy object that hides the network and server implementation details. This loosely coupled architecture makes it difficult for client-side enhancements, such as method caching and validation, to obtain useful information about server state and implementation. Statically-generated custom proxies can provide a limited solution, but are troublesome to deploy and cannot change dynamically at runtime. This thesis presents a framework for Java RMI smart proxies using a distributed aspectoriented platform. The framework allows server-controlled dynamic changes to Java RMI proxy objects on the client, without requiring changes to the client application code or development cycle. The benefits of this framework are demonstrated with three practical examples: method caching, client-side input validation, and load balancing

    RAFDA: A Policy-Aware Middleware Supporting the Flexible Separation of Application Logic from Distribution

    Get PDF
    Middleware technologies often limit the way in which object classes may be used in distributed applications due to the fixed distribution policies that they impose. These policies permeate applications developed using existing middleware systems and force an unnatural encoding of application level semantics. For example, the application programmer has no direct control over inter-address-space parameter passing semantics. Semantics are fixed by the distribution topology of the application, which is dictated early in the design cycle. This creates applications that are brittle with respect to changes in distribution. This paper explores technology that provides control over the extent to which inter-address-space communication is exposed to programmers, in order to aid the creation, maintenance and evolution of distributed applications. The described system permits arbitrary objects in an application to be dynamically exposed for remote access, allowing applications to be written without concern for distribution. Programmers can conceal or expose the distributed nature of applications as required, permitting object placement and distribution boundaries to be decided late in the design cycle and even dynamically. Inter-address-space parameter passing semantics may also be decided independently of object implementation and at varying times in the design cycle, again possibly as late as run-time. Furthermore, transmission policy may be defined on a per-class, per-method or per-parameter basis, maximizing plasticity. This flexibility is of utility in the development of new distributed applications, and the creation of management and monitoring infrastructures for existing applications.Comment: Submitted to EuroSys 200

    A Peer-to-Peer Middleware Framework for Resilient Persistent Programming

    Get PDF
    The persistent programming systems of the 1980s offered a programming model that integrated computation and long-term storage. In these systems, reliable applications could be engineered without requiring the programmer to write translation code to manage the transfer of data to and from non-volatile storage. More importantly, it simplified the programmer's conceptual model of an application, and avoided the many coherency problems that result from multiple cached copies of the same information. Although technically innovative, persistent languages were not widely adopted, perhaps due in part to their closed-world model. Each persistent store was located on a single host, and there were no flexible mechanisms for communication or transfer of data between separate stores. Here we re-open the work on persistence and combine it with modern peer-to-peer techniques in order to provide support for orthogonal persistence in resilient and potentially long-running distributed applications. Our vision is of an infrastructure within which an application can be developed and distributed with minimal modification, whereupon the application becomes resilient to certain failure modes. If a node, or the connection to it, fails during execution of the application, the objects are re-instantiated from distributed replicas, without their reference holders being aware of the failure. Furthermore, we believe that this can be achieved within a spectrum of application programmer intervention, ranging from minimal to totally prescriptive, as desired. The same mechanisms encompass an orthogonally persistent programming model. We outline our approach to implementing this vision, and describe current progress.Comment: Submitted to EuroSys 200

    An AOP Layer to Abstract Programming with Distributed Components

    Get PDF
    International audienceComponent models such as EJB or CCM are increasingly used to create complex and distributed systems and applications. Unless the details of the API and mechanisms used for programming with these models differ, the general features provided by the models share many characteristics. In this paper, we propose to capture these features in a common layer that can be used to develop model independant component programs. The layer is then mapped either onto EJB or CCM. This layer is defined with the AspectJ aspect-oriented programming language. We report on two samples applications that were developped with this layer: an application-level load balancing service and a contract enforcement service

    Distributed aop middleware for large-scale scenarios

    Get PDF
    En aquesta tesi doctoral presentem una proposta de middleware distribuït pel desenvolupament d'aplicacions de gran escala. La nostra motivació principal és permetre que les responsabilitats distribuïdes d'aquestes aplicacions, com per exemple la replicació, puguin integrar-se de forma transparent i independent. El nostre enfoc es basa en la implementació d'aquestes responsabilitats mitjançant el paradigma d'aspectes distribuïts i es beneficia dels substrats de les xarxes peer-to-peer (P2P) i de la programació orientada a aspectes (AOP) per realitzar-ho de forma descentralitzada, desacoblada, eficient i transparent. La nostra arquitectura middleware es divideix en dues capes: un model de composició i una plataforma escalable de desplegament d'aspectes distribuïts. Per últim, es demostra la viabilitat i aplicabilitat del nostre model mitjançant la implementació i experimentació de prototipus en xarxes de gran escala reals.In this PhD dissertation we present a distributed middleware proposal for large-scale application development. Our main aim is to separate the distributed concerns of these applications, like replication, which can be integrated independently and transparently. Our approach is based on the implementation of these concerns using the paradigm of distributed aspects. In addition, our proposal benefits from the peer-to-peer (P2P) networks and aspect-oriented programming (AOP) substrates to provide these concerns in a decentralized, decoupled, efficient, and transparent way. Our middleware architecture is divided into two layers: a composition model and a scalable deployment platform for distributed aspects. Finally, we demonstrate the viability and applicability of our model via implementation and experimentation of prototypes in real large-scale networks
    corecore