ProActive: Programming, Composing, Deploying on the Grid

A Comprehensive Solution
for Grid Computing

OASIS Research Team

Version 3.2.1 2007-04-10


ProActive is a GRID middleware Java library for parallel, distributed, and concurrent computing, also featuring mobility and security in a uniform framework. With a reduced set of simple primitives, ProActive provides a comprehensive API allowing to simplify the programming of applications that are distributed on Local Area Network (LAN), on cluster of workstations, on P2P desktop Grids, or on Internet Grids. The library is based on an Active Object pattern that is a uniform way to encapsulate:

  • a remotely accessible object,

  • a thread as an asynchronous activity,

  • an actor with its own script,

  • a server of incoming requests,

  • a mobile and potentially secure entity.

On top of those basic features, ProActive also includes advanced aspects, such as:

  • Typed Group Communications,

  • Object-Oriented SPMD,

  • Distributed and Hierarchical Components,

  • Security,

  • Fault Tolerance with checkpointing,

  • a P2P infrastructure,

  • a powerful deployment model based on XML descriptors,

  • File transfer capabilities over the Grid,

  • a Graphical User Interface: IC2D.

ProActive is only made of standard Java classes, and requires no changes to the Java Virtual Machine, no preprocessing or compiler modification; programmers write standard Java code. Based on a simple Meta-Object Protocol, the library is itself extensible, making the system open for adaptations and optimizations. ProActive currently uses the RMI Java standard library as default portable transport layer, and also provides optimized RMI with IBIS, and HTTP transport.

ProActive features several optimizations improving performance. For instance, whenever two active objects are located within the same virtual machine, a direct communication is always achieved, without going through the network stack. This optimization is ensured even when the co-location occurs after a migration of one or both of the active objects.

ProActive and the (de facto) Standards: ProActive has an architecture that allows the library to interoperate with various official or de facto standards:

  • Web Service Exportation,

  • HTTP Transport, RMI/SSH tunneling Transport,

  • ssh, scp, rsh, rcp,

  • Globus GT2, GT3 and GT4, Unicore, GLite, ARC (NorduGrid), GSI-SSH,

  • LSF, PBS, Sun Grid Engine, OAR.

Contributors and Contact Information

Team Leader:

Denis Caromel INRIA 2004, Route des Lucioles BP 93 06902 Sophia Antipolis Cedex France phone: +33 492 387 631 fax: +33 492 387 971


  • Francoise Baude

  • Javier Bustos

  • Antonio Cansado

  • Vincent Cave

  • Arnaud Contes

  • Alexandre di Costanzo

  • Guillaume Chazarain

  • Christian Delbe

  • Ludovic Henrio

  • Fabrice Huet

  • Virginie Legrand

  • Mario Leyton

  • Clement Mathieu

  • Eric Madelaine

  • Stephane Mariani

  • Matthieu Morel

  • Marc Ozonne

  • Igor Rosenberg

  • Bernard Serpette

Past and External Contributors

  • Laurent Baduel

  • Alexandre Bergel

  • Roland Bertuli

  • Juan Casanova Rodriguez

  • Florian Doyon

  • Alexandre Fau

  • Stephane Jasinski

  • Felipe Luna

  • Elton Mathias

  • Olivier Nano

  • Nikos Parlavantzas

  • Arnaud Poizat

  • Romain Quilici

  • Nadia Ranaldo

  • Ward Vanlooy

  • Remi Vankeisbelck

  • Julien Vayssiere

  • Eugenio Zimeo

Public questions/comments/discussions should be posted on the ProActive public mailing list

Mailing list archive at


Post bugs to ProActive bug-tracking system GForge


List of Figures
List of Tables
List of Examples

Table of Contents

Part I. Introduction

Chapter 1. Principles
1.1. Seamless sequential, multithreaded and distributed
1.2. Active objects: Unifying threads and remote objects
1.3. Model of Computation
1.4. Reusablilty and Seamless interface: why and how do we achieve it?
1.5. Hello world ! (tiny example)
1.5.1. The TinyHello class
1.5.2. Implement the required functionality
1.5.3. Creating the Hello Active Object
1.5.4. Invoking a method on a remote object and printing out the message
1.5.5. Launching
Chapter 2. ProActive Installation
2.1. Quick Start
2.1.1. To Test ProActive with the examples
2.1.2. To develop with ProActive
2.2. Download and expand the archive
2.3. Run a few examples for testing
2.3.1. Local Example 1: Hello world !
2.3.2. Local Example 2: Reader/Writer
2.3.3. Local Example 3: The Dining Philosophers
2.3.4. Local Example 4: The N-Body Simulation
2.4. CLASSPATH to set when writing application using ProActive
2.5. Create a java.policy file to set permissions
2.6. Create a log4j configuration file
2.7. ProActive and IDEs (Eclipse, ...)
2.8. Troubleshooting and support
Chapter 3. ProActive Trouble Shooting
3.1. Enabling the loggers
3.2. Hostname and IP Address
3.3. Domaine name resolution problems
3.4. RMI Tunneling
3.5. Public remote method calls

Part II. Guided Tour and Tutorial

Chapter 4. Introduction to the Guided Tour and Tutorial
4.1. Overview
4.2. Installation and setup
Chapter 5. Introduction to ProActive Features
5.1. Parallel processing and collaborative application with ProActive
5.2. C3D: a parallel, distributed and collaborative 3D renderer
5.2.1. Start C3D
5.2.2. Start a user
5.2.3. Start a user from another machine
5.2.4. Start IC2D to visualize the topology
5.2.5. Drag-and-drop migration
5.2.6. Start a new JVM in a computation
5.2.7. Wrapping Active Objects in Components
5.2.8. Look at the source code for the main classes
5.3. Synchronization with ProActive
5.3.1. The readers-writers
5.3.2. The dining philosophers
5.4. Migration of active objects
5.4.1. Start the penguin application
5.4.2. Start IC2D to see what is going on
5.4.3. Add an agent
5.4.4. Add several agents
5.4.5. Move the control window to another user
Chapter 6. Hands-on programming
6.1. The client - server example
6.2. Initialization of the activity
6.2.1. Design of the application with Init activity
6.2.2. Programming
6.2.3. Execution
6.3. A simple migration example
6.3.1. Required conditions
6.3.2. Design
6.3.3. Programming
6.3.4. Execution
6.4. migration of graphical interfaces
6.4.1. Design of the migratable application
6.4.2. Programming
6.4.3. Execution
Chapter 7. PI (3.14...) - Step By Step
7.1. Software Installation
7.1.1. Installing the Java Virtual Machine
7.1.2. Download and install ProActive
7.2. Implementation
7.2.1. MyPi.java
7.2.2. Add the Deployment Descriptor
7.2.3. Instantiate The Remote Objects
7.2.4. Divide, Compute and Conquer
7.2.5. Clean up
7.2.6. Executing the application
7.3. Putting it all together
8.1. OO SPMD on a Jacobi example
8.1.1. Execution and first glance at the Jacobi code
8.1.2. Modification and compilation
8.1.3. Detailed understanding of the OO SPMD Jacobi
8.1.4. Virtual Nodes and Deployment descriptors
8.1.5. Execution on several machines and Clusters
8.2. OO SPMD on a Integral Pi example MPI to ProActive adaptation
8.2.1. Introduction
8.2.2. Initialization
8.2.3. Communication primitives
8.2.4. Running ProActive example
Chapter 9. The nbody example
9.1. Using facilities provided by ProActive on a complete example
9.1.1. Rationale and overview
9.1.2. Usage
9.1.3. Source files: ProActive/src/org/objectweb/proactive/examples/nbody
9.1.4. Common files
9.1.5. Simple Active Objects
9.1.6. Groups of Active objects
9.1.7. groupdistrib
9.1.8. Object Oriented SPMD Groups
9.1.9. Barnes-Hut
9.1.10. Conclusion
Chapter 10. C3D - from Active Objects to Components
10.1. Reason for this example
10.2. Using working C3D code with components
10.3. How the application is written
10.3.1. Creating the interfaces
10.3.2. Creating the Component Wrappers
10.3.3. Discarding direct reference acknowledgment
10.4. The C3D ADL
10.5. Advanced component highlights
10.5.1. Renaming Virtual Nodes
10.5.2. Component lookup and registration
10.6. How to run this example
10.7. Source Code
Chapter 11. Guided Tour Conclusion

Part III. Programming

Chapter 12. ProActive Basis, Active Object Definition
12.1. Active objects basis
12.2. What is an active object
Chapter 13. Active Objects: creation and advanced concepts
13.1. Instantiation-Based Creation
13.1.1. Possible ambiguities on the constructor
13.1.2. Using a Node
13.2. Object-Based Creation
13.3. Specifying the activity of an active object
13.3.1. Algorithms deciding which activity to invoke
13.3.2. Implementing the interfaces directly in the class
13.3.3. Passing an object implementing the interfaces at creation-time
13.4. Restrictions on reifiable objects
13.5. Using the Factory Method Design Pattern
13.6. Advanced: Customizing the Body of an Active Object
13.6.1. Motivations
13.6.2. How to do it
13.7. Advanced: Role of the elements of an active object
13.7.1. Role of the stub
13.7.2. Role of the proxy
13.7.3. Role of the body
13.7.4. Role of the instance of class B
13.8. Asynchronous calls and futures
13.8.1. Creation of a Future Object
13.8.2. Asynchronous calls in details
13.8.3. Important Notes: Errors to avoid
13.9. Automatic Continuation in ProActive
13.9.1. Objectives
13.9.2. Principles
13.9.3. Example
13.9.4. Illustration of an Automatic Continuation
13.10. The Hello world example
13.10.1. The two classes
13.10.2. Hello World within the same VM
13.10.3. Hello World from another VM on the same host
13.10.4. Hello World from abroad: another VM on a different host
Chapter 14. Typed Group Communication
14.1. Overview
14.2. Creation of a Group
14.3. Group representation and manipulation
14.4. Group as result of group communications
14.5. Broadcast vs Dispatching
Chapter 15. OOSPMD
15.1. OOSPMD: Introduction
15.2. SPMD Groups
15.3. Barrier: Introduction
15.4. Total Barrier
15.5. Neighbor barrier
15.6. Method Barrier
15.7. When does a barrier get triggered?
Chapter 16. Active Object Migration
16.1. Migration Primitive
16.2. Using migration
16.3. Complete example
16.4. Dealing with non-serializable attributes
16.5. Mixed Location Migration
16.5.1. Principles
16.5.2. How to configure
Chapter 17. Exception Handling
17.1. Exceptions and Asynchrony
17.1.1. Barriers around try blocks
17.1.2. TryWithCatch Annotator
17.1.3. Additional API
17.2. Non-Functional Exceptions
17.2.1. Overview
17.2.2. Exception types
17.2.3. Exception handlers
Chapter 18. Branch and Bound API
18.1. Overview
18.2. The Model Architecture
18.3. The API Details
18.3.1. The Task Description
18.3.2. The Task Queue Description
18.3.3. The ProActiveBranchNBound Description
18.4. An Example: FlowShop
18.5. Future Work
Chapter 19. High Level Patterns -- The Calcium Skeleton Framework
19.1. Introduction
19.1.1. About Calcium
19.1.2. The Big Picture
19.2. Quick Example
19.2.1. Define the skeleton structure
19.2.2. Implementing the Muscle
19.2.3. Create a new Calcium Instance
19.2.4. Provide an input of problems to be solved by the framework
19.2.5. Collect the results
19.2.6. View the performance statistics
19.3. Supported Patterns
19.4. Choosing a Resource Manager
19.5. Performance Statistics
19.5.1. Global Statistics
19.5.2. Result Statistics
19.6. Future Work

Part IV. Deploying

Chapter 20. ProActive Basic Configuration
20.1. Overview
20.2. How does it work?
20.3. Where to access this file?
20.4. ProActive properties
20.4.1. Required
20.4.2. Fault-tolerance properties
20.4.3. Peer-to-Peer properties
20.4.4. rmi ssh properties
20.4.5. Other properties
20.5. Configuration file example
Chapter 21. XML Deployment Descriptors
21.1. Objectives
21.2. Principles
21.3. Different types of VirtualNodes
21.3.1. VirtualNodes Definition
21.3.2. VirtualNodes Acquisition
21.4. Different types of JVMs
21.4.1. Creation
21.4.2. Acquisition
21.5. Validation against XML Schema
21.6. Complete description and examples
21.7. Infrastructure and processes
21.7.1. Local JVMs
21.7.2. Remote JVMs
21.7.3. DependentListProcessDecorator
21.8. Infrastructure and services
21.9. Killing the application
21.10. Processes
Chapter 22. Variable Contracts for Descriptors
22.1. Variable Contracts for Descriptors
22.1.1. Principle
22.1.2. Variable Types
22.1.3. Variable Types User Guide
22.1.4. Variables Example
22.1.5. External Variable Definitions Files
22.1.6. Program Variable API
Chapter 23. ProActive File Transfer Model
23.1. Introduction and Concepts
23.2. File Transfer API
23.2.1. API Definition
23.2.2. How to use the API
23.3. Descriptor File Transfer
23.3.1. XML Descriptor File Transfer Tags
23.4. Advanced: FileTransfer Design
23.4.1. Abstract Definition (High level)
23.4.2. Concrete Definition (Low level)
23.4.3. How Deployment File Transfer Works
23.4.4. How File Transfer API Works
23.4.5. How Retrieve File Transfer Works
Chapter 24. Using SSH tunneling for RMI or HTTP communications
24.1. Overview
24.2. Configuration of the network
24.3. ProActive runtime communication patterns
24.4. ProActive application communication patterns.
24.5. ProActive communication protocols
24.6. The rmissh communication protocol.
Chapter 25. Fault-Tolerance
25.1. Overview
25.1.1. Communication Induced Checkpointing (CIC)
25.1.2. Pessimistic message logging (PML)
25.2. Making a ProActive application fault-tolerant
25.2.1. Resource Server
25.2.2. Fault-Tolerance servers
25.2.3. Configure fault-tolerance for a ProActive application
25.2.4. A deployment descriptor example
25.3. Programming rules
25.3.1. Serializable
25.3.2. Standard Java main method
25.3.3. Checkpointing occurrence
25.3.4. Activity Determinism
25.3.5. Limitations
25.4. A complete example
25.4.1. Description
25.4.2. Running NBody example
Chapter 26. Technical Service
26.1. Context
26.2. Overview
26.3. Progamming Guide
26.3.1. A full XML Descriptor File
26.3.2. Nodes Properties
26.4. Further Information
Chapter 27. ProActive Grid Scheduler
27.1. The scheduler design:
27.2. The scheduler manual:
27.2.1. Job creation
27.2.2. Interaction with the scheduler
27.3. The Scheduler API
27.3.1. Classes
27.3.2. How to extend the scheduler

Part V. Composing

Chapter 28. Components introduction
Chapter 29. An implementation of the Fractal component model geared at Grid Computing
29.1. Specific features
29.1.1. Distribution
29.1.2. Deployment framework
29.1.3. Activities
29.1.4. Asynchronous method calls with futures
29.1.5. Collective interactions
29.1.6. Conformance
29.2. Implementation specific API
29.2.1. fractal.provider
29.2.2. Content and controller descriptions
29.2.3. Collective interactions
29.2.4. Requirements
29.3. Architecture and design
29.3.1. Meta-object protocol
29.3.2. Components vs active objects
29.3.3. Method invocations on components interfaces
Chapter 30. Configuration
30.1. Controllers and interceptors
30.1.1. Configuration of controllers
30.1.2. Writing a custom controller
30.1.3. Configuration of interceptors
30.1.4. Writing a custom interceptor
30.2. Lifecycle: encapsulation of functional activity in component lifecycle
30.3. Short cuts
30.3.1. Principles
30.3.2. Configuration
Chapter 31. Collective interfaces
31.1. Motivations
31.2. Multicast interfaces
31.2.1. Definition
31.2.2. Data distribution
31.2.3. Configuration through annotations
31.2.4. Binding compatibility
31.3. Gathercast interfaces
31.3.1. Definition
31.3.2. Data distribution
31.3.3. Process synchronization
31.3.4. Binding compatibility
Chapter 32. Architecture Description Language
32.1. Overview
32.2. Example
32.3. Exportation and composition of virtual nodes
32.4. Usage
Chapter 33. Component examples
33.1. From objects to active objects to distributed components
33.1.1. Type
33.1.2. Description of the content
33.1.3. Description of the controller
33.1.4. From attributes to client interfaces
33.2. The HelloWorld example
33.2.1. Set-up
33.2.2. Architecture
33.2.3. Distributed deployment
33.2.4. Execution
33.2.5. The HelloWorld ADL files
33.3. The Comanche example
33.4. The C3D component example
Chapter 34. Component perspectives: a support for our research work
34.1. Dynamic reconfiguration
34.2. Model-checking
34.3. Pattern-based deployment
34.4. Graphical user interface
34.4.1. Howto use it
34.5. Other
34.6. Limitations

Part VI. Advanced

Chapter 35. ProActive Peer-to-Peer Infrastructure
35.1. Overview
35.2. The P2P Infrastructure Model
35.2.1. What is Peer-to-Peer?
35.2.2. The P2P Infrastructure in short
35.3. The P2P Infrastructure Implementation
35.3.1. Peers Implementation
35.3.2. Dynamic Shared ProActive Group
35.3.3. Sharing Node Mechanism
35.3.4. Monitoring: IC2D
35.4. Installing and Using the P2P Infrastructure
35.4.1. Create your P2P Network
35.4.2. Example of Acquiring Nodes by ProActive XML Deployment Descriptors
35.4.3. The P2P Infrastructure API Usage Example
35.5. Future Work
35.6. Research Work
Chapter 36. Load Balancing
36.1. Overview
36.2. Metrics
36.2.1. MetricFactory and Metric classes
36.3. Using Load Balancing
36.3.1. In the application code
36.3.2. Technical Service
36.4. Non Migratable Objects
Chapter 37. ProActive Security Mechanism
37.1. Overview
37.2. Security Architecture
37.2.1. Base model
37.2.2. Security is expressed at different levels
37.3. Detailed Security Architecture
37.3.1. Nodes and Virtual Nodes
37.3.2. Hierarchical Security Entities
37.3.3. Resource provider security features
37.3.4. Interactions, Security Attributes
37.3.5. Combining Policies
37.3.6. Dynamic Policy Negotiation
37.3.7. Migration and Negotiation
37.4. Activating security mechanism
37.4.1. Construction of an XML policy:
37.5. How to quickly generate certificate?
Chapter 38. Exporting Active Objects and components as Web Services
38.1. Overview
38.2. Principles
38.3. Pre-requisite: Installing the Web Server and the SOAP engine
38.4. Steps to expose an active object or a component as a web services
38.5. Undeploy the services
38.6. Accessing the services
38.7. Limitations
38.8. A simple example: Hello World
38.8.1. Hello World web service code
38.8.2. Access with Visual Studio
38.9. C# interoperability: an example with C3D
38.9.1. Overview
38.9.2. Access with a C# client
38.9.3. Dispatcher methods calls and callbacks
38.9.4. Download the C# example
Chapter 39. ProActive on top of OSGi
39.1. Overview of OSGi -- Open Services Gateway initiative
39.2. ProActive bundle and service
39.3. Yet another Hello World
39.4. Current and Future works
Chapter 40. An extended ProActive JMX Connector
40.1. Overview of JMX - Java Management eXtention
40.2. Asynchronous ProActive JMX connector
40.3. How to use the connector ?
40.4. Notifications JMX via ProActive
40.5. Example : a simple textual JMX Console
Chapter 41. Wrapping MPI Legacy code
41.1. Simple Wrapping
41.1.1. Principles
41.1.2. API For Deploying MPI Codes
41.1.3. How to write an application with the XML and the API
41.1.4. Using the Infrastructure
41.1.5. Example with several codes
41.2. Wrapping with control
41.2.1. One Active Object per MPI process
41.2.2. MPI to ProActive Communications
41.2.3. ProActive to MPI Communications
41.2.4. MPI to MPI Communications through ProActive
41.2.5. USER STEPS - The Jacobi Relaxation example
41.3. Design and Implementation
41.3.1. Simple wrapping
41.4. Summary of the API
41.4.1. Simple Wrapping and Deployment of MPI Code
41.4.2. Wrapping with Control

Part VII. Graphical User Interface (GUI) and tools

Chapter 42. IC2D: Interactive Control and Debugging of Distribution and Eclipse plugin
42.1. Monitoring and Control
42.1.1. The Monitoring plugin
42.1.2. The Job Monitoring plugin
42.2. Launcher and Scheduler
42.2.1. The Launcher plug-in
42.2.2. The Scheduler plug-in
42.3. Programming Tools
42.3.1. ProActive Wizards
42.3.2. The ProActive Editor
42.4. The Guided Tour as Plugin
Chapter 43. Interface with Scilab
43.1. Presentation
43.2. Scilab Interface Architecture
43.3. Graphical User Interface (Scilab Grid ToolBox)
43.3.1. Launching Scilab Grid ToolBox
43.3.2. Deployment of the application
43.3.3. Task launching
43.3.4. Display of results
43.3.5. Task monitoring
43.3.6. Engine monitoring
Chapter 44. TimIt API
44.1. Overview
44.2. Quick start
44.2.1. Define your TimIt configuration file
44.2.2. Add time counters and event observers in your source files
44.3. Usage
44.3.1. Timer counters
44.3.2. Event observers
44.4. TimIt extension
44.4.1. Configuration file
44.4.2. Timer counters
44.4.3. Event observers
44.4.4. Chart generation

Part VIII. Extending ProActive

Chapter 45. How to write ProActive documentation
45.1. Aim of this chapter
45.2. Getting a quick start into writing ProActive doc
45.3. Example use of tags
45.3.1. Summary of the useful tags
45.3.2. Figures
45.3.3. Bullets
45.3.4. Code
45.3.5. Links
45.3.6. Tables
45.4. DocBok limitations imposed
45.5. Stylesheet Customization
45.5.1. File hierarchy
45.5.2. What you can change
45.5.3. The Bible
45.5.4. Profiling
45.5.5. The XSL debugging nightmare
45.5.6. DocBook subset: the dtd
45.5.7. Todo list, provided by Denis
Chapter 46. Adding Grahical User Interfaces and Eclipse Plugins
46.1. Architecture and documentation
46.1.1. org.objectweb.proactive.ic2d.monitoring
46.1.2. org.objectweb.proactive.ic2d.console
46.1.3. org.objectweb.proactive.ic2d.lib
46.2. Extending IC2D
46.2.1. How to checkout IC2D
46.2.2. How to implement a plug-in for IC2D
Chapter 47. Developing Conventions
47.1. Code logging conventions
47.1.1. Declaring loggers name
47.1.2. Using declared loggers in your classes
47.1.3. Managing loggers
47.1.4. Logging output
47.1.5. More information about log4j
47.2. Regression Tests Writing
47.3. Committing modifications in the SVN
Chapter 48. ProActive Test Suite API
48.1. Structure of the API
48.1.1. Goals of the API
48.1.2. Functional Tests & Benchmarks
48.1.3. Group
48.1.4. Manager
48.2. Timer for the Benchmarks
48.2.1. The solution
48.2.2. How to use Timer in Benchmarck?
48.2.3. How to configure the Manager with your Timer?
48.3. Results
48.3.1. What is a Result?
48.3.2. What we don't use a real logger API?
48.3.3. Structure of Results classes in TestSuite
48.3.4. How to export results
48.3.5. Format Results like you want
48.4. Logs
48.4.1. Which logger?
48.4.2. How it works in TestSuite API?
48.4.3. How to use it?
48.5. Configuration File
48.5.1. How many configuration files you need?
48.5.2. A simple Java Properties file
48.5.3. A XML properties file
48.6. Extends the API
48.7. Your first Test
48.7.1. Description
48.7.2. First step: write the Test
48.7.3. Second step: write a manager
48.7.4. Now launch the test ...
48.7.5. Get the results
48.7.6. All the code
48.8. Your first Benchmark
48.8.1. Description
48.8.2. First step: write the Benchmark
48.8.3. Second step: write a manager
48.8.4. Now launch the benchmark ...
48.8.5. All the Code
48.9. How to create a Test Suite with interlinked Tests
48.9.1. Description of our Test
48.9.2. Root Test: ProActive Group Creation
48.9.3. An independant Test: A Group migration
48.9.4. Run your tests
48.9.5. All the code
48.10. Conclusion
Chapter 49. Adding a Deployment Protocol
49.1. Objectives
49.2. Overview
49.3. Java Process Class
49.3.1. Process Package Arquitecture
49.3.2. The New Process Class
49.3.3. The StartRuntime.sh script
49.4. XML Descriptor Process
49.4.1. Schema Modifications
49.4.2. XML Parsing Handler
Chapter 50. How to add a new FileTransfer CopyProtocol
50.1. Adding external FileTransfer CopyProtocol
50.2. Adding internal FileTransfer CopyProtocol
Chapter 51. Adding a Fault-Tolerance Protocol
51.1. Overview
51.1.1. Active Object side
51.1.2. Server side
Chapter 52. MOP: Metaobject Protocol
52.1. Implementation: a Meta-Object Protocol
52.2. Principles
52.3. Example of a different metabehavior: EchoProxy
52.3.1. Instantiating with the metabehavior
52.4. The Reflect interface
52.5. Limitations

Part IX. Back matters

Appendix A. Frequently Asked Questions
A.1. Running ProActive
A.1.1. How do I build ProActive from the distribution?
A.1.2. Why don't the examples and compilation work under Windows?
A.1.3. Why do I get a Permission denied when trying to launch examples scripts under Linux?
A.2. General Concepts
A.2.1. How does the node creation happen?
A.2.2. How does the RMI Registry creation happen?
A.2.3. What is the class server, why do we need it?
A.2.4. What is a reifiable object?
A.2.5. What is the body of an active object? What are its local and remote representations?
A.2.6. What is a ProActive stub?
A.2.7. Are the call to an Active Object always asynchronous?
A.3. Exceptions
A.3.1. Why do I get an exception java.lang.NoClassDefFoundError about asm?
A.3.2. Why do I get an exception java.lang.NoClassDefFoundError about bcel?
A.3.3. Why do I get an exception java.security.AccessControlException access denied?
A.3.4. Why do I get an exception when using Jini?
A.3.5. Why do I get a java.rmi.ConnectException: Connection refused to host: ?
A.4. Writing ProActive-oriented code
A.4.1. Why aren't my object's properties updated?
A.4.2. How can I pass a reference on an active object or the difference between this and ProActive.getStubOnThis()?
A.4.3. How can I create an active object?
A.4.4. What are the differences between instantiation based and object based active objects creation?
A.4.5. Why do I have to write a no-args constructor?
A.4.6. How do I control the activity of an active object?
A.4.7. What happened to the former live() method and Active interface?
A.4.8. Why should I avoid to return null in methods body?
A.4.9. How can I use Jini in ProActive?
A.4.10. How do I make a Component version out of an Active Object version?
A.4.11. How can I use Jini in ProActive?
A.4.12. Why is my call not asynchronous?
A.5. Deployment Descriptors
A.5.1. What is the difference between passing parameters in Deployment Descriptor and setting properties in ProActive Configuration file?
A.5.2. Why do I get the following message when parsing my xml deployment file: ERROR: file:~/ProActive/descriptor.xml Line:2 Message:cvc-elt.1: Cannot find the declaration of element 'ProActiveDescriptor'
Appendix B. Reference Card
B.1. Main concepts and definitions
B.2. Main principles: asynchronous method calls and implicit futures
B.3. Explicit Synchronization
B.4. Programming AO Activity and services
B.5. Reactive Active Object
B.6. Service methods
B.7. Active Object Creation:
B.8. Groups:
B.9. Explicit Group Synchronizations
B.11. Migration
B.12. Components
B.13. Security:
B.14. Deployment
B.15. Exceptions
B.16. Export Active Objects as Web services
B.17. Deploying a fault-tolerant application
B.18. Peer-to-Peer Infrastructure
B.19. Branch and Bound API
B.20. File Transfer Deployment
Appendix C. Files of the ProActive source base cited in the manual
C.1. XML descriptors cited in the manual
C.2. Java classes cited in the manual
C.3. Tutorial files : Adding activities and migration to HelloWorld
C.4. Other files cited in the manual