All Classes and Interfaces
Class
Description
Abstract implementation of
ClassLoaderConnection.Instances of this class manage the node's class loader and associated operations.
This class is used as a container for common methods that cannot be implemented in
AbstractNode.Common abstact super class for connection strategies that read connection from groups of comma-separated values.
This class is a custom class loader serving the purpose of dynamically loading the JPPF classes and the client
application classes, to avoid costly redeployment system-wide.
This class is a custom class loader serving the purpose of dynamically loading the JPPF classes and the client
application classes, to avoid costly redeployment system-wide.
Abstract implementation of the
Node interface.Abstract impelementation of
ClassLoaderConnection.This class performs the I/O operations requested by the JPPFNode, for reading the task bundles and sending the results back.
Instances of this class manage the execution of JPPF tasks by a node.
Instances of this class represent the connection between a node's class loader and the driver.
Event emitted by an
AbstractJPPFClassLoader when a class is loaded or not found for the first time.Interface to implement for the objects that wish to receive notifications
of JPPF class loader events.
Interface for a class loader provider.
This class manages the batching of class loading requests at regular intervals.
Instances of this class define the context for a node (re)connection request.
This enum lists the possible high-level reasons for a node reconnection request.
The default node life cycle error handler, used when the life cycle listener implementation does not implement
NodeLifeCycleErrorHandler.This default hook is used when none is specified in the node configuration.
This class registers as a NodeLifeCycleListener and instantiates an implementation of
NodeIntegration,
if any is defined in the configuration.This interface provides the required information for connecting to a remote JPPF driver.
This interface defines which parameters should be used to connect to the driver.
This extension of JFrale ensures that the frame is brought to the fore,
on top of any other window, when
toFront() is called.URL stream handler for the "jppfres:" protocol, which handles class loader cache resources stored in memory.
Interface for custom discovery of the driver to connect to.
This NodeLifeCycleListener implementations parses the classpath associated with a job
and adds its elemenents to the task class loader.
Get job results from a queue and send them back to the driver.
JPPF class loader implementation for remote standalone nodes.
Instances of this class represent dynamic class loading, and serialization/deserialization, capabilities, associated
with a specific client application.
The application is identified through a unique uuid.
The application is identified through a unique uuid.
This implementation of
DriverConnectionStrategy reads a list of drivers
from a CSV file where each line has the following format:This implementation of
DriverConnectionStrategy reads a list of drivers from a configuration property with the following format:This implementation of
DriverConnectionStrategy is the JPPF default
and produces DriverConnectionInfo instances based solely on the JPPF configuration.A default implementation for the
DriverConnectionInfo interface.Implementation for class loader leak prevention.
JPPF class loader implementation for nodes running within the same JVM as the JPPF server (local nodes).
Instances of this class encapsulate execution nodes.
Service provider interface for pluggable management beans for JPPF nodes.
Implementation of the
JPPFNodeProvisioningMBean interface.NodeProvisioningMBean provider implementation, discovered by JPPF via the service provider API.
This error is thrown to notify a node that its code is obsolete and it should dynamically reload itself.
Provides a callback to determine when a node accepts new jobs
Implementation of a
URLConnection for the "jppfres:" URL protocol.This is the interface to implement for any custom implementation of a screen saver associated with a JPPF node.
A built-in screen saver implementation.
This class handles the firing of node life cycle events and the listeners that subscribe to these events.
A throttling mechanism that causes a node to not accept jobs whenever heap usage reaches a configured percentage of the maximum heap size.
This MBean notifies any listener of changes to the number of threads of a node.
Instances of this class represent the connection between a node's class loader and the driver.
NodeDebugMBean provider implementation, discovered by JPPF via the service provider API.
Instances of this class manage the execution of JPPF tasks by a node.
This interface groups two other interfaces, from which an external can receive notifications from the node.
This interface groups two other interfaces, from which the screen saver can receive notifications from the node.
An abstract adapter class for receiving node events.
An abstract adapter class for receiving node events.
Internal interface for methods of a node that shoudln't be exposed in the public API.
This interface defines how a node receives a job and sends its execution results.
Bootstrap class for launching a JPPF node.
Interface for handling uncaught throwables raised when executing one of the methods of
NodeLifeCycleListener.Instances of this class represent node life cycle events.
A type safe enumeration of all possible types of node life cycle events.
Interface for all listeners to the node's life cycle events.
Convenience class that can be used when not all methods of
NodeLifeCycleListener need to be implemented.This class displays the connection status, execution status and number of tasks for a node.
Bootstrap class for launching a JPPF node.
Instances of this class represent information about a node.
This class loads and invokes all implementations of the
JPPFNodeThrottling service found in the classpath.Instances of this class are used to deserialize objects from an
incoming message in parallel.
The goal of this class is to serialize an object before sending it back to the server, and catch an eventual exception.
This initialization redirects the dirver's or node's stdout and stderr to specified files.
Concrete implementation of
ClassLoaderConnection for connecting to a remote driver.Instances of this class are used as cache for resources downloaded from a driver or client, using the JPPF class loader APIs.
Privileged action wrapper for saving a resource definition to a temporary file.
Main entry point for starting the screen saver.
This interface represents a hook invoked when the serialization of a task raises an exception.
Task used to terminate the JVM.
The protocol handler which executes commands sent to a slave node by its master node.
A built-in simple screen saver implementation.
This class wraps a single slave node process and provides an API to start, stop and monitor it.
This class manages the slave nodes.