ProActive: Programming, Composing, Deploying on the Grid

A Comprehensive Solution For
Multithreaded, Parallel, Distributed,
And Concurrent Computing

OASIS Research Team

Version 2008-07-11 10:57:34 2008-07-11 10:57:34

Contributors and Contact Information

Team Leader:

                  Denis Caromel

                  INRIA 2004, Route des Lucioles

                   BP 93


                  Sophia Antipolis Cedex


                  phone: +33 492 387 631

                  fax: +33 492 387 971


ActiveEon Team
  • Christian Delbé

  • Arnaud Contes

  • Vladimir Bodnartchouk

  • Emil Salageanu

OASIS Team Past And External Important Contributors

  • Guillaume Laurent

  • Robert Lovas

  • Jonathan Martin

  • Elton Mathias

  • Maxime Menant

  • Guilherme Perretti Pezzi

  • Franca Perrina

  • Kamran Qadir

  • Bastien Sauvan

  • Germain Sigety

  • Etienne Vallette-De-Osia

  • Laurent Vanni

  • Yulai Yuan

  • Sylvain Cussat-Blanc

  • Boutheina Bennour

  • Vincent Cave

  • Guillaume Chazarain

  • Clement Mathieu

  • Eric Madelaine

  • Brian Amedro

  • Florin Bratu

  • Tomasz Dobek

  • Khan Muhammad

  • Julian Krzeminski

  • Zhihui Dai

  • Baptiste De Stefano

  • Nicolas Dodelin

  • Yu Feng

  • Imen Filiali

  • Johann Fradj

  • Abhijeet Gaikwad

  • Regis Gascon

  • Jean-Michael Guillamume

  • Abhishek-Rajeev Gupta

  • Elaine Isnard

  • Vasile Jureschi

  • Francoise Baude

  • Antonio Cansado

  • Marcela Rivera

  • Ludovic Henrio

  • Fabrice Huet

  • Virginie Contes

  • Mario Leyton

  • Paul Naoumenko

  • Viet Dong Doan

  • Fabien Viale

  • Cédric Dalmasso

  • Jean-Luc Scheefer

  • Lionel Mestre

  • Matthieu Morel

  • Guillaume Chazarain

  • Laurent Baduel

  • Alexandre di Costanzo

  • Romain Quilici

  • Nadia Ranaldo

  • Julien Vayssiere

Public questions, comments, or discussions can pe posted on the ProActive public mailing list

The mailing list archive is placed at


Bugs can be posted on the ProActive Jira bug-tracking system


List of Figures
List of Examples

Part I. Introduction

Chapter 1. ProActive Overview
1.1. ProActive Programming Frameworks
1.1.1. Introduction
1.1.2. Active Objects Model
1.1.3. Implementation Language
1.1.4. Communication through typed asychronous messages
1.1.5. Programming With Components: GCM
1.1.6. Library features
Chapter 2. ProActive And IC2D Installation
2.1. ProActive Installation Overview
2.1.1. Testing ProActive With The Examples
2.1.2. Developing With ProActive
2.2. ProActive Detailed Installation Steps
2.2.1. Download And Expand The Archive
2.2.2. Set the CLASSPATH for using ProActive to write applications
2.2.3. Create a java.policy File To Set Permissions
2.2.4. A simple proactive-log4j file
2.2.5. Run A Few Examples For Testing
2.3. IC2D Installation
2.3.1. Normal Usage Installation
2.3.2. Development Installation
2.3.3. ProActive Scheduler GUI Installation
Chapter 3. ProActive Troubleshooting
3.1. Common problems
3.2. Enabling the loggers
3.3. Domaine name resolution problems
3.4. RMI Tunneling

Part II. Guided Tour and Tutorial

Chapter 4. Introduction To The Guided Tour and Tutorial
4.1. Overview
4.2. Installation and setup
4.3. ProActive and IDEs (Eclipse, ...)
Chapter 5. ProActive Example Applications
5.1. C3D: A distributed 3D renderer
5.1.1. How to use C3D
5.2. Readers/Writers Application
5.2.1. How to use the Readers/Writers
5.3. The dining philosophers
5.3.1. How to use the philosophers application
5.4. Migration of active objects
5.4.1. How to use the penguin application
5.4.2. How to use the Penguin Controller
5.5. Chat example
5.5.1. How to run the Chat application
5.5.2. Chat migration
5.6. Integral Pi
5.6.1. Introduction
5.6.2. Initialization
5.6.3. Communication primitives
5.6.4. Running the PI example
5.7. The nbody example
5.7.1. How to run the n-body example
5.7.2. Barnes-Hut
5.8. C3D - Active Objects to Components
5.8.1. Refactoring C3D with components
5.8.2. Creating the interfaces
5.8.3. Creating the Component Wrappers
5.8.4. Component lookup and registration
5.8.5. How to run components C3D
5.8.6. Conclusion
Chapter 6. Active Object Tutorial
6.1. Simple Computation And Monitoring Agent
6.1.1. Classes Used
6.1.2. CMA Architecture and Skeleton Code
6.1.3. Proposed Work
6.1.4. Solutions and Full Code
6.2. Active Objects Lifecycle: Using InitActive and EndActive
6.2.1. Classes Used
6.2.2. Initialized CMA Architecture and Skeleton Code
6.2.3. Proposed Work
6.2.4. Solution and Full Code
6.3. Application Deployment
6.3.1. Deployment Related Concepts
6.3.2. Deployment Descriptor File
6.4. Remote Monitoring Agent
6.4.1. Classes Used
6.4.2. Deployed CMA Architecture and Skeleton Code
6.4.3. Proposed Work
6.4.4. Solution and Full Code
6.5. Agent synchronization
6.5.1. Classes Used
6.5.2. Architecture and Skeleton Code
6.5.3. Proposed Work
6.5.4. Solution And Full Code
6.6. Monitoring Several Computers Using Migration
6.6.1. Classes Used
6.6.2. Design of Migratable Monitoring Agent and Skeleton Code
6.6.3. Proposed Work
6.6.4. Solution and Full Code
6.7. Groups of Monitoring Agents
6.7.1. Classes Used
6.7.2. Architecture and Skeleton Code
6.7.3. Proposed Work
6.7.4. Solution And Full Code
6.8. Monitoring Agent As A Web Service
6.8.1. Classes Used
6.8.2. Architecture and Skeleton Code
6.8.3. Proposed Work
6.8.4. Solution And Code
6.9. Primality test tutorial
6.9.1. A Sequential Version of the Primality Test
6.9.2. Architecture of the Sequential Version
6.9.3. Implementation of the Sequential Version
6.9.4. Running the Sequential Version
6.10. A Distributed Version of the Primality Test
6.10.1. Classes Used
6.10.2. Architecture of the Distributed Version
6.10.3. Solution/Full Code
6.10.4. Running the Distributed Version
6.11. A Distributed Version of the Primality Test Using the Master-Worker API
6.11.1. Classes Used
6.11.2. Architecture of the Master-Worker Version
6.11.3. Solution/Full Code
6.11.4. Running the Master-Worker Version
Chapter 7. High-Level API Tutorials
7.1. Master-Worker DistributedPrimes Application
7.1.1. Application components
7.1.2. Running master-worker Distributed Primes
Chapter 8. GCM Components Tutorial
8.1. Introduction
8.2. Key features of the ProActive/GCM Implementation
8.2.1. Primitive and composite components
8.2.2. Collective Interfaces
8.2.3. Multicast Interfaces
8.2.4. Gathercast interfaces
8.2.5. ADL file
8.3. Creating and using components in a programatic way
8.3.1. The first component
8.3.2. Define an assembly
8.4. Create and use components using ADL
8.5. Creating, using and deploying components using ADL
8.6. Component interface Cardinality
8.7. Additional examples

Part III. Programming With Active Objects

Chapter 9. Active Object Definition
9.1. Overview
9.2. Active Object Structure
Chapter 10. Active Objects: Creation And Advanced Concepts
10.1. Overview
10.2. Restrictions on creating active objects
10.3. Instantiation Based Creation
10.3.1. Using PAActiveObject.newActive(...)
10.3.2. Using PAActiveObject.newActiveInParallel(...)
10.4. Object Based Creation using PAActiveObject.turnActive(...)
10.5. Active Object Creation Arguments
10.5.1. Using classname and target
10.5.2. Using Constructor Arguments
10.5.3. Using A Node
10.5.4. Using A Custom Activity
10.5.5. Using the factory pattern with Active Objects
10.5.6. Using MetaObjectFactory to customize the meta objects
10.6. Elements of an active object and futures
10.6.1. Role of the stub
10.6.2. Role of the proxy
10.6.3. Role of the body
10.6.4. Role of the instance of class Worker
10.7. Asynchronous calls and futures
10.7.1. Creation of a Future Object
10.7.2. Methods affected by futures
10.7.3. Asynchronous calls in details
10.7.4. Good ProActive programming practices
10.7.5. Lightweight failure detection
10.8. Automatic Continuation in ProActive
10.8.1. Sending Futures
10.8.2. Receiving Futures
10.8.3. Illustration of an Automatic Continuation
10.9. Data Exchange between Active Objects
Chapter 11. Typed Group Communication
11.1. Overview
11.2. Instantiation Typed Group Creation
11.3. Group representation and manipulation
11.4. Group as result of group communications
11.5. Broadcast vs Dispatching
11.6. Access By Name
11.7. Unique serialization
Chapter 12. Mobile Agents And Migration
12.1. Migration Overview
12.2. Using Migration
12.3. Complete example
12.4. Dealing with non-serializable attributes
12.4.1. Using The MigrationStrategyManager Interface
12.4.2. Using readObject(...) and writeObject(...)
12.5. Mixed Location Migration
12.5.1. Forwarders And Agents
12.5.2. Forwarder And Agent Parameters
12.5.3. Configuration File
12.5.4. Location Server
Chapter 13. Exception Handling
13.1. Exceptions and Asynchrony
13.1.1. Barriers around try blocks
13.1.2. TryWithCatch Annotator
13.1.3. throwArrivedException() and waitForPotentialException()

Part IV. Programming With High Level APIs

Chapter 14. Master-Worker API
14.1. Overview
14.2. Logger Settings
14.3. Master Creation And Deployment
14.3.1. Local Master creation
14.3.2. Remote Master creation
14.4. Adding Resources
14.5. Tasks definition and submission
14.6. Results retrieval and reception order
14.7. Terminating the master
14.8. Worker ping period
14.9. Worker task flooding
14.10. Worker Memory
14.10.1. Structure and API
14.10.2. Storing data
14.10.3. Retrieving and using the data
14.11. Monte-Carlo PI Example
Chapter 15. The Calcium Skeleton Framework
15.1. Introduction
15.1.1. About Calcium
15.1.2. The Big Picture
15.2. Quick Example
15.2.1. Define the skeleton structure
15.2.2. Implementing the Muscle Functions
15.2.3. Create a new Calcium Instance
15.2.4. Provide an input of problems to be solved by the framework
15.2.5. Collect the results
15.2.6. View the performance statistics
15.3. Supported Patterns
15.4. Execution Environments
15.4.1. MultiThreadedEnvironment
15.4.2. ProActiveEnvironment
15.4.3. ProActiveSchedulerEnvironment (unstable)
15.5. File Access and Transfer Support (beta)
15.5.1. WorkSpace
15.5.2. Annotated Muscle Functions
15.5.3. Muscle Function Example
15.5.4. Input and Output Files from the framework
15.6. Performance Statistics (beta)
15.6.1. Global Statistics
15.6.2. Local Result Statistics
Chapter 16. OOSPMD
16.1. OOSPMD: Introduction
16.2. SPMD Group Creation
16.3. Synchronizing activities with barriers
16.3.1. Total Barrier
16.3.2. Neighbour barrier
16.3.3. Method Barrier
16.4. MPI to ProActive Summary
Chapter 17. Wrapping Application Legacy code
17.1. Simple Wrapping
17.1.1. Principles
17.1.2. API For Deploying MPI Codes
17.1.3. How to write an application with the XML and the API
17.1.4. Using the Infrastructure
17.1.5. Example with several codes
17.2. Wrapping with control
17.2.1. One Active Object per MPI process
17.2.2. MPI to ProActive Communications
17.2.3. ProActive to MPI Communications
17.2.4. MPI to MPI Communications through ProActive
17.2.5. USER STEPS - The Jacobi Relaxation example
17.3. Design and Implementation
17.3.1. Simple wrapping
17.4. Summary of the API
17.4.1. Simple Wrapping and Deployment of MPI Code
17.4.2. Wrapping with Control

Part V. Deployment And Virtualization

Chapter 18. ProActive Basic Configuration
18.1. Overview
18.2. How does it work?
18.3. Where to access this file?
18.3.1. ProActive Default Configuration file
18.3.2. User-defined ProActive Configuration file
18.3.3. Alternate User Configuration file
18.4. ProActive properties
18.4.1. Required
18.4.2. Fault-tolerance properties
18.4.3. Peer-to-Peer properties
18.4.4. rmi ssh properties
18.4.5. Other properties
18.5. Configuration file example
Chapter 19. ProActive GCM Deployment
19.1. Introduction
19.2. ProActive Deployment API
19.2.1. Resources fixed by applications (SPMD)
19.2.2. Resources fixed by the deployer
19.2.3. On demand Scalability
19.3. GCM Deployment Descriptors
19.3.1. Host Information
19.3.2. Bridges
19.3.3. Groups
19.4. GCM Application descriptor
19.4.1. Executable
19.4.2. ProActive
19.5. FAQ
19.6. Tutorial
19.6.1. For the Grid Administrator : creating a deployment descriptor
19.6.2. For the Grid Application Developer : creating an application descriptor
19.6.3. For the Grid Application Developer : deploying your application on the grid
Chapter 20. XML Deployment Descriptors
20.1. Objectives
20.2. Principles
20.3. Different types of VirtualNodes
20.3.1. VirtualNodes Definition
20.3.2. VirtualNodes Acquisition
20.4. Different types of JVMs
20.4.1. Creation
20.4.2. Acquisition
20.5. Validation against XML Schema
20.6. Complete description and examples
20.7. Infrastructure and processes
20.7.1. Local JVMs
20.7.2. Remote JVMs
20.7.3. DependentListProcessDecorator
20.8. Infrastructure and services
20.9. How to terminate a ProActive application
20.9.1. Destroying active objects
20.9.2. Killing JVMs
20.10. Processes
Chapter 21. Variable Contracts for Descriptors
21.1. Variable Contracts for Descriptors
21.1.1. Principle
21.1.2. Variable Types
21.1.3. Variable Types User Guide
21.1.4. Variables Example
21.1.5. External Variable Definitions Files
21.1.6. Program Variable API
Chapter 22. ProActive File Transfer
22.1. Introduction and Concepts
22.2. File Transfer API
22.2.1. API Definition
22.2.2. How to use the API Example
22.3. Descriptor File Transfer
22.3.1. XML Descriptor File Transfer Tags
22.4. Advanced: FileTransfer Design
22.4.1. Abstract Definition (High level)
22.4.2. Concrete Definition (Low level)
22.4.3. How Deployment File Transfer Works
22.4.4. How File Transfer API Works
22.4.5. How Retrieve File Transfer Works
Chapter 23. Using SSH tunneling for RMI or HTTP communications
23.1. Overview
23.2. Configuration of the network
23.3. ProActive runtime communication patterns
23.4. ProActive application communication patterns.
23.5. ProActive communication protocols
23.6. The rmissh communication protocol.
Chapter 24. Technical Service
24.1. Context
24.2. Overview
24.3. Progamming Guide
24.3.1. A full XML Descriptor File
24.3.2. Nodes Properties
24.4. Further Information

Part VI. Programming With Components

Chapter 25. Introduction
Chapter 26. Getting started
Chapter 27. User guide
27.1. Architecture Description Language
27.1.1. Overview
27.1.2. Exportation and composition of virtual nodes
27.1.3. Usage
27.2. Deployment
27.3. Collective interfaces
27.3.1. Motivations
27.3.2. Multicast interfaces
27.3.3. Gathercast interfaces
27.4. Implementation specific API
27.4.1. fractal.provider
27.4.2. Requirements
27.4.3. Content and controller descriptions
27.4.4. Collective interfaces
27.4.5. Priority controller
27.4.6. Stream ports
27.5. Advanced
27.5.1. Controllers and interceptors
27.5.2. Lifecycle: encapsulation of functional activity in component lifecycle
27.5.3. Structuring the membrane with non-functional components
27.6. Short cuts
27.6.1. Principles
27.6.2. Configuration
Chapter 28. Architecture and design
28.1. Meta-object protocol
28.2. Components vs active objects
28.3. Method invocations on components interfaces
Chapter 29. Component examples
29.1. From objects to active objects to distributed components
29.1.1. Type
29.1.2. Description of the content
29.1.3. Description of the controller
29.1.4. From attributes to client interfaces
29.2. The HelloWorld example
29.2.1. Set-up
29.2.2. Architecture
29.2.3. Distributed deployment
29.2.4. Execution
29.2.5. The HelloWorld ADL files
Chapter 30. Component perspectives: a support for advanced research
30.1. Dynamic reconfiguration
30.2. Model-checking
30.3. Pattern-based deployment
30.4. Graphical tools
Chapter 31. Annex
31.1. The starter example files

Part VII. Services and Advanced Features

Chapter 32. Load Balancing
32.1. Overview
32.2. Metrics
32.2.1. MetricFactory and Metric classes
32.3. Using Load Balancing
32.3.1. In the application code
32.3.2. Technical Service
32.4. Non Migratable Objects
Chapter 33. Fault-Tolerance
33.1. Overview
33.1.1. Communication Induced Checkpointing (CIC)
33.1.2. Pessimistic message logging (PML)
33.2. Making a ProActive application fault-tolerant
33.2.1. Resource Server
33.2.2. Fault-Tolerance servers
33.2.3. Configure fault-tolerance for a ProActive application
33.2.4. A deployment descriptor example
33.3. Programming rules
33.3.1. Serializable
33.3.2. Standard Java main method
33.3.3. Checkpointing occurrence
33.3.4. Activity Determinism
33.3.5. Limitations and known bugs
33.4. A complete example
33.4.1. Description
33.4.2. Running NBody example
Chapter 34. Security Framework
34.1. Overview
34.2. Security Architecture
34.2.1. Base model
34.2.2. Security is expressed at different levels
34.3. Detailed Security Architecture
34.3.1. Nodes and Virtual Nodes
34.3.2. Hierarchical Security Entities
34.3.3. Resource provider security features
34.3.4. Interactions, Security Attributes
34.3.5. Combining Policies
34.3.6. Dynamic Policy Negotiation
34.3.7. Migration and Negotiation
34.4. How to create policy files and certificates
34.5. Activating security mechanism
34.6. The XML Security Descriptor in details
34.6.1. Construction of an XML policy:
Chapter 35. Exporting Active Objects and components as Web Services
35.1. Overview
35.2. Principles
35.3. Pre-requisite: Installing the Web Server and the SOAP engine
35.4. Steps to expose an active object or a component as a web services
35.5. Undeploy the services
35.6. Accessing the services
35.7. Limitations
35.8. A simple example: Hello World
35.8.1. Hello World web service code
35.8.2. Access with Visual Studio
35.9. C# interoperability: an example with C3D
35.9.1. Overview
35.9.2. Access with a C# client
35.9.3. Dispatcher methods calls and callbacks
35.9.4. Download the C# example
Chapter 36. ProActive on top of OSGi
36.1. Overview of OSGi -- Open Services Gateway initiative
36.2. ProActive bundle and service
36.3. Yet another Hello World
36.4. Current and Future works
Chapter 37. An extended ProActive JMX Connector
37.1. Overview of JMX - Java Management eXtention
37.2. Asynchronous ProActive JMX connector
37.3. How to use the connector ?
37.4. Notifications JMX via ProActive
37.5. Example : a simple textual JMX Console
Chapter 38. Existing MBean and JMX notifications in ProActive
38.1. Principles
38.2. How to subscribe/unsubscribe to the notifications of a MBean?
38.2.1. Subscribe to the JMX notifications of a ProActive object
38.2.2. Unsubscribe to the JMX notifications
38.3. The ProActive JMX Notifications
38.3.1. How to send a JMX notification?
38.3.2. example of notification listener
38.3.3. The JMX notifications sent by the ProActive MBean

Part VIII. Graphical User Interface (GUI) and tools

Chapter 39. IC2D: Interactive Control and Debugging of Distribution
39.1. Monitoring and Control
39.1.1. The Monitoring plugin
39.1.2. The Job Monitoring plugin
39.1.3. The TimIt plugin
39.2. Launcher
39.2.1. Principles
39.2.2. MainDefinition tag
39.2.3. API
39.2.4. The Launcher Plug-in
39.3. Programming Tools
39.3.1. ProActive Wizards
39.3.2. The ProActive Editor
39.4. The Guided Tour as Plugin
Chapter 40. Interface with Matlab/Scilab
40.1. Presentation
40.1.1. Motivations
40.1.2. Features
40.2. Graphical User Interface (Matlab/Scilab Grid ToolBox)
40.2.1. Installation for Scilab
40.2.2. Installation for Matlab
40.2.3. Configuration of the GUI
40.2.4. Launching Matlab/Scilab Grid ToolBox
40.2.5. Deployment of the application
40.2.6. Task launching
40.2.7. Display of results
40.2.8. Task monitoring
40.2.9. Engine monitoring
40.3. Matlab embedded parallelization
40.3.1. Installation
40.3.2. Usage
40.4. Advanced Usage
40.4.1. Matlab/Scilab GUI Architecture
Chapter 41. TimIt API
41.1. Overview
41.2. Quick start
41.2.1. Define your TimIt configuration file
41.2.2. Add time counters and event observers in your source files
41.3. Usage
41.3.1. Timer counters
41.3.2. Event observers
41.4. TimIt extension
41.4.1. Configuration file
41.4.2. Timer counters
41.4.3. Event observers
41.4.4. Chart generation

Part IX. Extending ProActive

Chapter 42. How to write ProActive documentation
42.1. Aim of this chapter
42.2. Getting a quick start into writing ProActive doc
42.3. Example use of tags
42.3.1. Summary of the useful tags
42.3.2. Figures
42.3.3. Bullets
42.3.4. Code
42.3.5. Links
42.3.6. Tables
42.4. DocBok limitations imposed
42.5. Stylesheet Customization
42.5.1. File hierarchy
42.5.2. What you can change
42.5.3. The Bible
42.5.4. Profiling
42.5.5. The XSL debugging nightmare
42.5.6. DocBook subset: the dtd
42.5.7. Todo list, provided by Denis
Chapter 43. Adding Grahical User Interfaces and Eclipse Plugins
43.1. Architecture and documentation
43.1.1. org.objectweb.proactive.ic2d.monitoring
43.1.2. org.objectweb.proactive.ic2d.console
43.1.3. org.objectweb.proactive.ic2d.lib
43.2. Extending IC2D
43.2.1. How to checkout IC2D
43.2.2. How to implement a plug-in for IC2D
43.3. How to create the IC2D stand-alone application from the sources
43.3.1. Required
43.3.2. First step: Import required libraries in the 'org.objectweb.proactive.ic2d.lib' plug-in
43.3.3. Second step: Import the different plug-ins in Eclipse
43.3.4. Third step: Launch IC2D in Eclipse
43.3.5. Last step: Export IC2D
43.3.6. FAQ
43.3.7. UseFul links
Chapter 44. Developing Conventions
44.1. Code logging conventions
44.1.1. Declaring loggers name
44.1.2. Using declared loggers in your classes
44.1.3. Managing loggers
44.1.4. Logging output
44.1.5. More information about log4j
44.2. Regression Tests Writing
44.3. Committing modifications in the SVN
Chapter 45. Adding a Deployment Protocol
45.1. Objectives
45.2. Overview
45.3. Java Process Class
45.3.1. Process Package Arquitecture
45.3.2. The New Process Class
45.3.3. The StartRuntime.sh script
45.4. XML Descriptor Process
45.4.1. Schema Modifications
45.4.2. XML Parsing Handler
Chapter 46. How to add a new FileTransfer CopyProtocol
46.1. Adding external FileTransfer CopyProtocol
46.2. Adding internal FileTransfer CopyProtocol
Chapter 47. Adding a Fault-Tolerance Protocol
47.1. Overview
47.1.1. Active Object side
47.1.2. Server side
Chapter 48. MOP: Metaobject Protocol
48.1. Implementation: a Meta-Object Protocol
48.2. Principles
48.3. Example of a different metabehavior: EchoProxy
48.3.1. Instantiating with the metabehavior
48.4. The Reflect interface
48.5. Limitations

Part X. Extensions Under Development

Chapter 49. Branch and Bound API
49.1. Overview
49.2. The Model Architecture
49.3. The API Details
49.3.1. The Task Description
49.3.2. The Task Queue Description
49.3.3. The ProActiveBranchNBound Description
49.4. An Example: FlowShop
49.5. Future Work
Chapter 50. P2P Infrastructure With ProActivee
50.1. Installing and Using the P2P Infrastructure
50.1.1. Create your P2P Network
50.1.2. Example of Acquiring Nodes by ProActive XML Deployment Descriptors
50.1.3. The P2P Infrastructure API Usage Example
50.2. Overview
50.3. The P2P Infrastructure Model
50.3.1. What is Peer-to-Peer?
50.3.2. The P2P Infrastructure in short
50.4. The P2P Infrastructure Implementation
50.4.1. Peers Implementation
50.4.2. Dynamic Shared ProActive Group
50.4.3. Sharing Node Mechanism
50.4.4. Monitoring: IC2D
50.5. Future Work
50.6. Research Work

Part XI. Back matters

Appendix A. Frequently Asked Questions
A.1. Frequently Asked Questions
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.1.4. How does the node creation happen?
A.1.5. How does the RMI Registry creation happen?
A.1.6. What is the class server, why do we need it?
A.1.7. What is a reifiable object?
A.1.8. What is the body of an active object? What are its local and remote representations?
A.1.9. What is a ProActive stub?
A.1.10. Are the call to an Active Object always asynchronous?
A.1.11. Why do I get an exception java.lang.NoClassDefFoundError about asm?
A.1.12. Why do I get an exception java.lang.NoClassDefFoundError about bcel?
A.1.13. Why do I get an exception java.security.AccessControlException access denied?
A.1.14. Why do I get an exception when using Jini?
A.1.15. Why do I get a java.rmi.ConnectException: Connection refused to host: ?
A.1.16. Why aren't my object's properties updated?
A.1.17. How can I pass a reference on an active object or the difference between this and PAActiveObject.getStubOnThis()?
A.1.18. How can I create an active object?
A.1.19. What are the differences between instantiation based and object based active objects creation?
A.1.20. Why do I have to write a no-args constructor?
A.1.21. How do I control the activity of an active object?
A.1.22. What happened to the former live() method and Active interface?
A.1.23. Why should I avoid to return null in methods body?
A.1.24. How can I use Jini in ProActive?
A.1.25. How do I make a Component version out of an Active Object version?
A.1.26. How can I use Jini in ProActive?
A.1.27. Why is my call not asynchronous?
A.1.28. What is the difference between passing parameters in Deployment Descriptor and setting properties in ProActive Configuration file?
A.1.29. 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 Active Objects' 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