All Classes and Interfaces
Class
Description
Instances of this class manage the execution of JPPF tasks by a node.
Convenience class for collecting time or size statistics.
An extension of
AbstractObjectPoolQueue which specifies a maximum size for the pool.Abstract implementation of the
Bundler interface.Common abstract super class for chromosme implementations.
A
ConcurrentHashMap whose values are Collection instances (specialized in concrete subclasses).A
Hashtable whose values are Collection instances (specialized in concrete subclasses).A map whose values are collections of a given component type.
A sorted map whose values are sets of a given component type.
Converts the JPPF predefined properties into the "Configuration properties reference" section of the doc as wiki text.
A persistence implementation which stores data in a single database table.
A wrapper for a connection and some of its characteristics.
Abstract implementation of the
DataLocation interface.Instances of this class manage the execution of JPPF tasks by a node.
Common super class for expressions written as the value of configuration properties containing;
properties substitutions and scripted values, i.e. containing expressions of the form "
${<property_name>}"
or "$script:<language>:<script_source>{<inline_script_or_script_location>}$".Filter that only accepts directories.
Abstract common superclass for file-based persistence implementations.
A filter that only matches directories.
Abstract super class for classes that Generate source code for forwarding to node MBeans.
Common abstract super class for a connection dedicated to recovery from hardware failure of a remote peer.
Represents a pattern used for IP addresses inclusion or exclusion lists.
A pattern represents a single value or a range of values for each component of an IP address.
A pattern represents a single value or a range of values for each component of an IP address.
Common abstract super class for execution policy rules that encapsulate a test of type IP is in Subnet string.
Wrapper around a JMX connection, providing a thread-safe way of handling disconnections and recovery.
This class is a wrapper around a JMX management server.
A map cache with a LRU eviction policy.
Abstract implementation of the
JPPFProperty interface.Abstract superclass for all JPPFQueue implementations.
Convenience class for collecting time or size statistics.
Instances of this class represent the location of an artifact, generally a file or the data found at a url.
Abstrat super class for generated node MBean forwarding proxies.
Instances of this class manage all management plugins defined through the Service Provider Interface.
Abstract super class for all generated MBean static proxies.
An abstract interceptor implementation which creates or obtains streams from the Socket or SocketChannel
passed on to its methods.
Context associated with an open communication channel.
Common abstract superclass representing a message sent or received by a channel.
Common abstract superclass representing a message sent or received by a channel.
Abstract implementation of the
NioObject interface, providing the means to keep stateful information
across multiple calls to the read() or write() methods.A thread-safe, dynamic object pool backed by a
LinkedBlockingQueue.A thread-safe, dynamic object pool backed by a
HashMap.Abstract superclass for privileged actions used to invoke a method or constructor through reflection when a security manager is present.
This class wraps a single slave node process and provides an API to start, stop and monitor it.
Instances of this class are dedicated to reading resource files form the JVM's classpath and converting them into
arrays of bytes.
A specfic serialization handler for
ConcurrentHashMap.Common abstract superclass for all socket clients.
Wrapper for an
SSLEngine and an associated channel.Abstract superclass for all tasks submitted to the execution server.
Instances of this class represent tasks that are part of a dependency graph of tasks within a job.
Dependencies can be added using the
Dependencies can be added using the
dependsOn(Collection<TaskNode>) and dependsOn(TaskNode...) methods.Common abstract superclass for non-JPPF tasks wrappers.
Abstract implementation of a
ThreadDumpWriter.This class manages the thread for the node's execution manager.
Extension of the
java.util.Properties class to handle the conversion of string values to other types.An execution policy rule that accepts everything.
This task performs the processing of a newly accepted channel.
Context associated with a channel serving tasks to a node.
Instances of this class serve task execution requests to the JPPF nodes.
Selects all drivers.
A job selector which accepts all jobs.
Selects all nodes.
This class implements the basis of a profile based on simulated annealing
jppf.load.balancing.profile.
A
HashMap whose values are ArrayLists of a given component type.A sorted map whose values are
ArrayLists of a given component type.Instances of this interface manage the execution of JPPF tasks by a node.
An asynchronous wrapper for any other load-balancer persistence implementation.
An asynchronous wrapper for any other job persistence implementation.
An asynchronous logger that delegates to an underlying SLF4J logger asychronously.
An execution policy rule that encapsulates a test of type
property_value_or_expression >= a.Performs a "at least" comparison between a job metadata value or job name and an other comparable value.
An execution policy rule that encapsulates a test of type
property_value_or_expression <= a.Performs a "at most" comparison between a job metadata value or a job name and an other comparable value.
This class implements a self tuned bundle size algorithm.
Provider implementation for the autotuned, Monte Carlo-based, load-balancing algorithm.
Instances of this bundler delegate their operations to a singleton instance of a
AutoTunedBundler.Encodes and decodes to and from Base64 notation.
A
Base64InputStream will read data from another InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.A
Base64OutputStream will write data to another OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.Base class for implementing and embedding all sorts of scripted logic.
An execution policy rule that encapsulates a test of type
a < property_value_or_expression < b.Performs a comparison of type "strictly more than lower_bound and strictly less than upper_bound" between a
Comparable metadata value or a job name
and Comparable lower and upper bounds.An execution policy rule that encapsulates a test of type
a < property_value <= b.Performs a comparison of type "strictly more than lower_bound and at most upper_bound" between a
Comparable metadata value or a job name
and Comparable lower and upper bounds.An execution policy rule that encapsulates a test of type
a <= property_value_or_expression < b.Performs a comparison of type "at least lower_bound and strictly less than upper_bound" between a
Comparable metadata value or a job name
and Comparable lower and upper bounds.An execution policy rule that encapsulates a test of type
a <= property_value_or_expression <= b.Performs a comparison of type "at least lower_bound and at most upper_bound" between a
Comparable metadata value or a job name
and Comparable lower and upper bounds.An expression that represents a boolean value as either a literal or an expression that returns a boolean.
Implementation of
JPPFProperty for boolean properties.This serializer is used solely by the nodes to enable their bootstrapping.
This class provides a simple API to transfer objects over a TCP socket connection.
A byte ArrayOutputStream with a maximum size of data that can be written into it.
A bounded pool which holds byte arrays with a fixed size.
Constants used when a client sends an admin command to a server.
This is the interface of all strategies for defining bundle task size.
A bundler which provides a more advanced feedback method with additional performance data.
Collection of static utility methods to help with bundler operations.
A convenient class to associate a
TaskBundle and a list of Tasks.A caching wrapper for any other implementation of
JobPersistence.Task wrapper for classes implementing
Callable.This interface should be implemented by tasks that wish a callback invoked as soon
as they are cancelled.
Concrete
Bundlers should implement this interface if they wish to have access to a node's configuration.Input source backed by a
ReadableByteChannel.An
InputStream implementation that reads from an underlying ReadableByteChannel which is assumed to be in blocking mode.Output destination backed by a
WritableByteChannel.An
OutputStream implementation that writes to an underlying WritableByteChannel which is assumed to be in blocking mode.Implementation of
JPPFProperty for char properties.Interface for a chromosome.
Nio message that reads or writes a single object from/to the network.
A container for class path elements.
Instances of this class represent classpath elements that can be added dynamically to a JPPF class loader.
A simple implementation of the
ClassPathElement interface.A simple implementation of the
ClassPath interfaceInstances of this class represent the connection information and configuration of a JPPF connection pool on the client side.
Abstract superclass for custom driver discovery mechanisms in JPPF clients.
Implementations of this interface provide environment properties to add to or override those passed to
JMXConnectorFactory.newJMXConnector() when the client side of a JMX connection is attempted.A helper class to handle close operations throughout a JVM.
Interface for maps whose values are collections of a given component type.
Interface for sorted maps whose values are collections of a given component type.
This class provides a set of utility methods for manipulating and converting
collections and arrays.
Instances of this class encapsulate the execution of an external process, program or shell script.
This task starts and external process using command line arguments, environment variables, and a list of input and/or output files to use or generated by the external process.
This task also captures the standard and error output (i.e. equivalent to System.out and System.err) of the external process.
This task starts and external process using command line arguments, environment variables, and a list of input and/or output files to use or generated by the external process.
This task also captures the standard and error output (i.e. equivalent to System.out and System.err) of the external process.
Interface for numerical binary comparison operators.
A set of utility methods to facilitate concurrent and multithreaded rpogramming.
Instances of this class are intended for grouping multiple class loading requests together.
Instances of this class allow an SSLSocketFactory or an SSLEngine to perform checks against multiple trust managers from multiple trusstores.
A specfic serialization handler for
ConcurrentHashMap.A concurrent
set implementation backed by a ConcurrentHashMap.A concurrent map whose values are soft references.
A set of utility methods to facilitate concurrent and multithreaded programming.
This interface represents a condition to evaluate to either
true or false.This interface handles exceptions raised by its
evaluate() method and returns false when it happens.This class handles the loading and saving of temporary configuration overrides files.
Extract JPPF properties defined as public constants in a given class.
An execution policy rule that encapsulates a test of type
property_value_or_expression contains a.Performs an "contains" comparison between a job metadata value or a job name and an other comparable value.
Bundler implementations should implement this interface if they wish to have access to a node's context.
A
ConcurrentHashMap whose values are CopyOnWriteArrayList instances.This class computes, at regular intervals, the approximative value of the CPU load
for the current JVM.
Utility and helper methods to deal with cryptographic operations.
In this implementation,
getLatest() is computed as the cumulated sum of all values added to the snapshot.Abstract superclass for all user-defined policies.
A job persistence implementation which stores jobs in a single database table.
This interface represents an abstraction of a block of data, regardless of where it is stored.
Instances of this class provide a way for tasks to share common data.
This interface must be implemented by tasks that are not implementations of
Task
when they need access to the job's DataProvider.Utility methods for date and time manipulation and conversion.
This class performs periodic deadlock checks and prints detailed deadlock information,
along with a thread dump, to the log, the first time a deadlock is detected.
A thread that prints out the call stack when
DebuggableThread.interrupt() is called.A job persistence implementation which stores jobs in a single database table.
A file-based persistent store for jobs.
This implementation uses the default Java serialization.
This implementation uses the JPPF serialization.
This class is the built-in JPPF monitoring data provider.
Enumeration of available delegation models for the JPPF class loaders.
A file walker that deletes a complete file and folder hierarchy.
This comparator defines a descending value order for integers.
Implementation of the
DiagnosticsMBean interface.Interface for the diagnostics MBean.
Forwarding proxy for the
DiagnosticsMBean MBean.Static factory for pool of direct byte buffers.
A ByteBuffer pool backed by a
ConcurrentLinkedQueue.Implementation of
JPPFProperty for double properties.Superclass for connection info in custom driver discovery mechanisms.
Abstract superclass for custom driver discovery mechanisms.
Listener interface to receive notifications of new discovered driver connection pools.
This is the job management MBean interface.
Marker interface for selecting drivers.
An enumeration that contains no element.
A map whose keys and values are elements of an enum type.
Instances of this class load and provide access to environment proivders.
An execution policy rule that encapsulates a test of type
property_value_or_expression equals a.Performs an "equals" comparison between a job metadata value or a job name and an other comparable value.
A serializable extension of the
Runnable interface.An interface to run arbitrary code that does not return any result and may raise an exception.
This class provides a set of utility methods for manipulating
Throwable objects.Instances of this class hold statistics about the execution of a tasks bundle.
Instances of this interface manage the execution of JPPF tasks by a node.
Interface for all execution policy implementations.
An execution policy that realizes a logical "AND" combination of multiple policies specified as operands.
An execution policy that realizes the negation of a policy specified as operand.
An execution policy that realizes a logical "OR" combination of multiple policies specified as operands.
An execution policy that realizes a logical "XOR" combination of multiple policies specified as operands.
Selects nodes based on an
ExecutionPolicy.Execution context associated with a channel serving its state.
Event sent to notify of a status change for a client connection.
Instances of this class listen to execution status change events on channels.
Status of the channel.
Interface for values that can be represented as either literals or expressions similar to the values of JPPF
configuration properties that include property substituions and/or scripted expressions.
Data location backed by a file.
Input source backed by a file.
File-based persistence implementation for the state of the JPPF load-balancers.
Wrapper for manipulating a file.
Output destination backed by a file.
Implementation of
JPPFProperty for File properties.Utility to replace multiline content in text files.
File filter based on a set of extensions.
A secure store source that uses a file as source.
This class provides a set of utility methods for reading, writing and manipulating files.
This class provide a used defined bundle size jppf.load.balancing.profile.
Provider implementation for the fixed bundle size load-balancing algorithm.
Profile for the fixed bundle size load-balancing algorithm.
Implementation of
JPPFProperty for float properties.Convenience interface to use in place of
NotificationListener when regstering a notification listener
that receives notifications from a NodeForwardingMBean.Represents a gene within a chromosme.
This class represents a snapshot of the JVM health.
Interface for classes that which to programmatically trigger a heap dump of the current JVM.
This factory class generates instances of
HeapDumpCollector based on
the vendor name found in System.getProperty("java.vm.vendor").Generate a heap dump for an IBM JVM.
Generate a heap dump for an Oracle JVM.
Client-side connection for the recovery mechanism.
Event emitted when a remote peer detects the connection with the server is broken.
This interface should be implemented buy objects that wish to be notified
of a broken connection with the server on the remote peer side.
Instances of this class represent heartbeat data exchanged between a driver and a node, client or peer driver.
Factcory methods for the registration and invocation of hooks.
Instance of a
Hook.This enum defines the possible types of hooks that can be defined.
Instances of this class represent a hostname / ip address pair.
Converts the JPPF predefined properties into the "Configuration properties reference" section of the doc as wiki text.
This class generates an HTML doc based on HTML templates and text files for the content.
The goal is to programmatically realize something like a client-side include for HTML documents.
The goal is to programmatically realize something like a client-side include for HTML documents.
Visits the JPPF MBean in a remote JVM and generates a reference documentation page in HTML format.
Implementation of a formatter that print the contents of a
Properties object as HTML.This class prints a thread dump nicely formatted as HTML to a character stream.
This class detects that no mouse or keyboard has occurred for a specified time,
and performs a specified action when this happens.
Enumeration for the possible states of the system.
Event emitted when the idle state of an
IdleDetectionTask changes.Listener interface for objects that wish to be notified of idle state changes.
This interface represents an abstraction of any source of incoming data.
Implementation of
JPPFProperty for properties whose value is an array of space-separated ints.This class loads, and provides access to, the
NetworkConnectionInterceptors discovered via SPI.This notification filter wraps the user-defined filter and determines whether
notifications should be sent to the JMX client based, on the associated node
selector and MBean name, in addition to the wrapped filter's logic.
This interface should be implemented by JPPF task classes that wish to control
whether they can be interrupted upon cancellation or timeout.
Implementation of
JPPFProperty for int properties.Instances of this class hold a reference to an object than can be either of the specified parametrized type or an exception.
Super interface for all input source and output destination implementations.
Collection of utility methods to create and manipulate IO objects.
Instances of this class handle IP address inclusion and exclusion filters constructed from the JPPF configuration.
Represents a netmask used for IP addresses include or exclude lists.
A netmask is in CIDR notation and represents an IP address of which only the first N bits are significant.
A netmask is in CIDR notation and represents an IP address of which only the first N bits are significant.
Represents a pattern used for IP addresses include or exclude lists.
A pattern represents a single value or a range of values for each component of an IP address.
A pattern represents a single value or a range of values for each component of an IP address.
Represents a netmask used for IPv6 addresses inclusion and exclusion lists.
A netmask is in CIDR notation and represents an IPv6 address of which only the first N bits are significant.
A netmask is in CIDR notation and represents an IPv6 address of which only the first N bits are significant.
Represents a pattern used for IPv6 addresses inclusion and exclusion lists.
A pattern represents a single value or a range of values for each component of an IPv6 address.
A pattern represents a single value or a range of values for each component of an IPv6 address.
An execution policy rule that encapsulates a test of type IPv4 is in
Subnet string.
An execution policy rule that encapsulates a test of type IPv6 is in Subnet string.
An execution policy predicate which determines whether a a connection endpoint is a local executor (on the client side) or a local node (on the server side).
An execution policy predicate which determines whether a node is a master node.
Performs an "is one of" comparison between a job metadata value or a job name and a set of other comparable values.
An execution policy predicate that determines whether a node connection is actually a peer driver.
An execution policy predicate which determines whether a node is a slave node.
Wraps an Iterator as an Enumeration
A specfic serialization handler for
Vector.An appender that delegates message appending to a JmxLogger.
Wrapper around a JMX connection, providing a thread-safe way of handling disconnections and recovery.
Event sent when a JMXConnectionWrapper is connected or when the connection times out.
Listner interface for objects that wish to be notified when a JMX connection is established or times out after a specified delay.
Driver-specific JMX connection wrapper, implementing a user-friendly interface for the monitoring
and management of a JPPF driver.
A handler that prints log messages as JMX notifications.
MBean interface for sending log and trace messages as JMX notifications.
Implementation of a simple logger that sends logged messages as JMX notifications.
Instances of this class send messages as JMX notifications.
Wrapper around the JMXMP remote connector server implementation.
Node-specific JMX connection wrapper, implementing a user-friendly interface for the monitoring and management of a node.
Interface for JMX remote servers associated to drivers and nodes.
This class provides factory methods to create rmeorte JMX connector servers.
Bundler implementations should implement this interface if they wish to have access to a job's information.
This interface represents the Service Level Agreement between a JPPF job and a JPPF client.
This interface represents the Service Level Agreement between a JPPF job and a server.
A representation of the jobs dependencies graph.
A representation of the jobs dependencies graph.
A simple management interface for the server-side job dependency graph.
Instances of this class represent a node in the job dependencies graph.
Instances of this class represent the definition of a job and its dependencies.
This enum describes the types of events emitted by a JPPFJobManager.
Instances of this class provide information about the state of a job being processed by a driver.
Listener interface for job manager events.
Instances of this interface hold metadata about a job, that can be used from a driver or node extension or plugin.
A job selector which accepts all jobs whose names are in the set specified in one of its constructors.
Instances of this class represent events emitted by a JPPFJobManager.
Notification interface for job manager events.
This interface must be implemented by services that perform jobs persistence in the driver.
Exceptions of this class are raised whenever an error occurs during a job persistence operation.
Factory class which instantites persistence implementations based on the JPPF configuration.
Enumeration of the possible reasons why a set of tasks is returned by a node in a given state.
Interface used to select or filter jobs in a client, driver or node.
This interface represents the Service Level Agreement between a JPPF job and a server.
Instances of this class encapsulate information on job dispatches to nodes.
Listener interface for classes that wish to receive notifications of job tasks dispatched or returned in the driver.
Implementations of this interface manage the registration and unregistration
of
job tasks listeners and notify these listeners of job tasks events.A job selector which accepts all jobs whose uuids are in the set specified in one of its constructors.
Management interface for the administration of a JPPF component, driver or node.
JPPF task wrapper for an object whose class is annotated with
JPPFRunnable.Instances of this class broadcast JPPF driver information at regular intervals,
to a configured UDP multicast group, to enable automatic discovery by clients,
nodes and peer drivers.
buffer for the data read from or written to a socket connection.
Factory class for JPPF load-balancing algorithms defined through the
JPPFBundlerProvider
service provider interface.This enum defines the available default load balancing configurations.
Interface for all load-balancing algorithm providers.
Extension of
ByteArrayOutputStream, providing
a faster toByteArray() method that does not involve copying its internal buffer.A serializable extension of the
Callable interface.This interface class represents objects that are run at client startup time.
Interface for caches implementations that rely on simple collections (as opposed to maps).
Abstract super class for serialization schemes that delegate to another serialization scheme.
Utility class for loading and accessing the JPPF configuration properties.
Implement this interface to provide an alternate configuration source via an
InputStream.Implement this interface to provide an alternate configuration source via a
Reader.This class encapsulates the connection information for a JPPF driver.
Bundler implementations should use this context if they wish to have access to execution context.
A non-pooled, non-XA datasource that provides connections using the
DriverManager API.This class represents a registry and factory for data sources defined via JPPF configuration properties.
Possible scopes.
The default uncaught exception handler for JPPF drivers and nodes.
Exception raised when a dependency cycle is detected between tasks or between jobs.
Filter that only accepts directories.
Common interface for client-side jobs (see
JPPFJob and server-side jobs
(see TaskBundle).MBean interface for the management of a JPPF driver.
This interface class represents objects that are run at server startup time.
Class of JPPF-specific error that may be caught in special cases.
Utility class used to collect error and warning messages for various operations,
including XML parsing and validation.
Class of exceptions for JPPF-specific exceptions.
Instances of this class are used to signal that a task could not be sent back by the node to the server.
Filter that only accepts files with specified extensions.
A handler that prints log messages using a
JPPFLogFormatter instance.A statistics listener with an optionally associated
snapshot filter.Cache implementation which uses a
HashMap.Channel identifiers sent over the network as part of the handshaking with a JPPF server.
Performs static initializations that must be done before anything else.
An enumeration of
JPPFProperty constants that apply to the JPPF jmx remote connector.Wrapper around the JMXMP remote connector server implementation.
Exception raised when a dependency cycle is detected in a graph of jobs.
Instances of this class hold metadata about a job, that can be used from a load-balancer,
to adapt the load balancing to the computational weight of the job and/or the contained tasks.
Formats log records in format yyyy-MM-dd hh:mm:ss.SSS [LEVEL][thread name][package.ClassName.method()]: message.
A map cache with a LRU eviction policy based on a specified capacity.
Instances of this class encapsulate the information required to access the JMX server of a node or a driver.
Interface for caches implementations with a map-like API.
Service provider interface for pluggable management beans.
Utility methods to obain and release
MBeanServer instances for embedded nodes.An instance of this class listens to messages broadcast by the driver
to get the driver connection host and ports.
Exposed interface of the JPPF node management bean.
Forwarding proxy for the
JPPFNodeAdminMBean MBean.Instances of this class are set as job SLA attributes and describe the desired node configuration for a job.
This MBean provides notifications of nodes connecting to, or disconnecting from a JPPF driver.
Deprecated.
Instances of this notification class wrap any JMX notification received from a node.
MBean interface for various maintenance operations on the nodes.
Forwarding proxy for the
JPPFNodeMaintenanceMBean MBean.Provides an interface for "master" nodes, giving them the ability to start, stop and monitor "slave" nodes on the same machine.
Forwarding proxy for the
JPPFNodeProvisioningMBean MBean.This interface represents objects that are run at node startup time.
Instances of this class represent the state of a node.
Enumeration of connection states.
Enumeration of execution states.
MBean interface for task-level monitoring on each node.
Forwarding proxy for the
JPPFNodeTaskMonitorMBean MBean.Implementation of
ObjectInputStream that reads objects without regards to whether
they implement Serializable or not.Implementation of
ObjectOutputStream that writes objects without regards to whether
they implement Serializable or not.This class holds a static enumeration of the documented JPPF configuration properties.
Interface for predefined JPPF properties expected to handle a specific value type.
This class provides information on a slave node, sent as a notification whenever a slave is started or stopped.
Implementation of a generic non-blocking queue, to allow asynchronous access from a large number of threads.
This class is for logging and debugging purposes.
This error is thrown to notify a node that its code is obsolete and it should dynamically reload itself.
A non-fair lock implementation that allows assigning a readable and identifiable name and
toString().Instances of this class encapsulate the necessary information used by the network classloader,
for sending class definition requests as well as receiving the class definitions.
Enumeration of the possible states for this resource wrapper.
Annotation to determine which method in a class is the task's main method.
A serializable extension of the
Runnable interface.Class of exceptions for JPPF-specific exceptions.
Instances of this class contain data used to setup a schedule.
This class handles a timer.
Exception thrown when an error occurs while executing a script.
Interface and factory for object serialization and deserialization schemes in JPPF.
Factory class for instantiating a default or configured serialization.
A collection of static utility methods to help with serialization in JPPF.
Cache implementation backed by a
Set wihh synchronized access.Convenience class for collecting time or size statistics.
Base class for filters including or excluding snpashots based on a provided set of labels.
Filter excluding snpashots based on a provided set of labels.
Filter including snpashots based on a provided set of labels.
Common super interface for node and server startup SPI interfaces.
Instances of this class hold statistics snapshots.
A filter interface for snapshots.
A statistics event.
This helper class holds the constants definitions for the labels
of the statistics snapshots used in JPPF, along with utility methods.
Listener interface for JPPF statistics.
This exception is thrown when a node is in suspended state and its connection was closed while performing I/O with the server.
Cache implementation which uses a
SoftReferenceValuesMap with synchronized access.This class encapsulates the system information for a node.
It includes: System properties, including -D flags Runtime information such as available processors and memory usage Environment variables JPPF configuration properties IPV4 and IPV6 addresses assigned to the JVM host Disk space information Server statistics (server-side only)
It includes: System properties, including -D flags Runtime information such as available processors and memory usage Environment variables JPPF configuration properties IPV4 and IPV6 addresses assigned to the JVM host Disk space information Server statistics (server-side only)
This class is kept for compatibility with existing user installations which make use of it,
as we understand there are quite a few that still do.
Instances of this class group tasks from the same client together, so they are sent to the same node,
avoiding unnecessary transport overhead.
The goal is to provide a performance enhancement through an adaptive bundling of tasks originating from the same client.
The goal is to provide a performance enhancement through an adaptive bundling of tasks originating from the same client.
Instances of this class are intended to be delegates for the
Task.onCancel() and Task.onTimeout() methods
for tasks that do not implement Task.Custom thread factory used mostly to specify the names of created threads.
A thread pool based on an ubounded queue which supports a core and maximum number of threads, along with a TTL for non-core threads.
A thread pool based on an ubounded queue which supports a core and maximum number of threads, along with a TTL for non-core threads.
Class of exceptions for JPPF timeout-related exceptions.
Exception raised to indicate that a call to a JPPF method is not supported.
Utility methods to generate UUIDs in various formats.
An extension of the
JPPFCallable whose JPPFVoidCallable.call() method always invokes the JPPFVoidCallable.run() method and returns null.Instances of this class listen to a socket connection setup in the ProcessLauncher, to handle the situation when the Launcher dies unexpectedly.
In that situation, the connection is broken and this process knows that it must exit.
In that situation, the connection is broken and this process knows that it must exit.
Interface for handling actions received from a
LauncherListener.An execution policy rule that encapsulates a test of type
property_value_or_expression < a.Performs a "less than" strict comparison between a job metadata value or a job name and an other comparable value.
A
HashMap whose values are ArrayLists of a given component type.A sorted map whose values are linked lists of a given component type.
This interface must be implemented by services that perform persistence of load-balancers state.
Exceptions of this class are raised whenever an error occurs during a load-balancer persistence operation.
Instances of this class represent the persisted information for a load-balancer.
Management interface for the load-balancer perisstence store.
This class is a common facade to the load-balancer persistence for both drivers and clients.
MBean interface for remote management of a server-side load-balancing persistence store.
Information on the load-balancing algorithm currently setup in the driver.
This interface defines the set of parameters used by a load-balancing algorithm.
Utility methods to localize messages in the JPPF components.
Abstraction of a block of data no matter how its actual location is referred to.
Instances of this class represent events occurring when performing I/O operations between
Location instances.Listener for events occurring with
Location objects.Information about a lock found in a
ThreadInformation object.An execution policy that realizes a binary logical combination of the policies specified as operands.
Implementation of
JPPFProperty for long properties.A cache with an LRU eviction policy.
A composite serialization scheme which applies a LZ4 compression/decompression to a concrete
JPPFSerialization implementation.This location provides a way to download artifacts from Maven Central, using a maven-like artifact location specification.
This location provides a way to download artifacts from a Maven repository, using a maven-like artifact location specification.
Used to annotate MBean elements with a meaningful descritpion that can be retrieved at runtime.
This annotation describes MBean method return types or parameters types, when the types are instances of generic types.
Used to annotate MBeans and MBean elements to specify whther they should be included in the reference documentation.
Visitor interface for exploring the information on all JPPF MBeans in a specified remote MBean server.
Functional interface to filter the MBean elements (attributes or operations) to visit.
Functional interface to filter the MBeans to visit.
An invocation handler used by MBean proxies created by JPPF.
Used to annotate MBean interfaces with a meaningful descritpion of the notifications they emit.
Used to annotate MBean method or constructor parametrs to assign them a meaningful nme, which can be applied to the automatically generated docupentation.
This class is an adapter for the
MBeanServerForwarder interface.This class generates the code of a static proxy for one or more specified MBean interfaces using Java reflection.
Instances of this class hold memory usage information.
Wrapper for manipulating a block of data in memory.
Implementation of a data provider that handles in-memory data backed by a
Map.A
Serializable implementation of MemoryUsage.A generic dictionary of metadata.
Enumeration of the built-in monitoring data fields.
Base class for pluggable providers of monitoring data.
This class provides methods to find, load and access
MonitoringDataProviders.Interface for converting monitored data values to displayable strings.
Specialized converter interface to transform
double values to strings.Specialized converter to transform
double values to a string with a specified number of fraction digits.Specialized converter interface to transform
float values to strings.Specialized converter interface to transform
int values to strings.Specialized converter interface to transform
long values to strings.An execution policy rule that encapsulates a test of type
property_value_or_expression > a.Performs a "more than" strict comparison between a job metadata value or a job name and an other comparable value.
An output stream implementation that minimizes memory usage.
Data location backed by a list of
JPPFBuffer.An output stream implementation that minimizes memory usage.
A representation of the jobs dependencies graph.
Holds a mutable object reference witho no locking or synchronization mechanism.
Implementations of this interface enable user-defined code to use the underlying network connection
to perform network I/O, typically implementing an authentication protocol.
Utility class that provides method to discover the network configuration of the current machine.
Context associated with an open communication channel.
Utility methods to help with managing nio servers.
Common interface for sending data over a communication channel.
Reads from the channel until no more data is available.
Writes all messages in the channel's context queue, if any, or keeps writing the current message until the socket send buffer is full.
Abstraction of a sequence of data read from, or written to a data channel.
Generic server for non-blocking asynchronous socket channel based communications.
Instances of this class rely on a number of possible states for each socket channel, along with the possible transitions between thoses states.
The design of this class enforces the use of typesafe enumerations for the states and transitions, so the developers must think ahead of how to implement their server as a state machine.
Instances of this class rely on a number of possible states for each socket channel, along with the possible transitions between thoses states.
The design of this class enforces the use of typesafe enumerations for the states and transitions, so the developers must think ahead of how to implement their server as a state machine.
Interface for a node that provides information about its activity.
This MBean notifies any listener of changes to the number of threads of a node.
Forwarding proxy for the
NodeConfigNotifierMBean MBean.MBean interface for forwarding node management requests and monitoring notfications via the driver.
Generate the source code for static proxies forwzrding requests to node MBeans through a driver.
Generate the source code for static proxies forwzrding requests to node MBeans through a driver.
Instances of this cass hold temporary information about a sub-job and the nodes it was dispatched to
An enumeration of the possible pending actions for a node, set via one of the
shutdown(false) or restart(false) methods of JPPFNodeAdminMBean.Interface that provides a semantic of matching a node against a selector.
Marker interface for selecting nodes when using the
NodeForwardingMBean methods.An execution policy rule that checks whether a specified number of nodes match a node execution policy.
Wrapper around a JPPF task used to catch exceptions caused by the task execution.
This implementation of a load-balancing algorithm illustrates the use of
the
ChannelAwareness APIs, by sending to each node at most m * n tasks,
where n is the number of processing threads in the node, and m is a
user-defined parameter which defaults to one.Provider implementation for the "nodethreads" algorithm.
Profile for the "nodethreads" load-balancing algorithm.
In this implementation,
getLatest() is computed as the average of the latest set of values that were added, or the latest value if only one was added.An execution policy rule that encapsulates a test of type
property_value_or_expression not_equal_to a.Performs a "not equal" comparison between a job metadata value or a job name and an other comparable value.
Possible types of notifications.
Input stream that delegates read and skip operations to an underlying stream,
and sends notifications of how many bytes were read or skipped via a callback.
Output stream that delegates write operations to an underlying stream,
and sends notifications of how many bytes were written via a callback.
This interface defines a callback used by notifying streams to provide notifications
of the bytes read, written or skipped.
Implementation of
JPPFProperty for numeric properties.An expression that represents a numeric value as either a literal or an expression that returns a numeric value.
A soft references cache of
ObjectName instances looked up with a single string name.Interface for oject pools.
Instances of this class are used to serialize or deserialize objects to or from an array of bytes.
A specific use of this class is that it can be loaded by a new classloader, making the execution transparent to any change in the client code.
A specific use of this class is that it can be loaded by a new classloader, making the execution transparent to any change in the client code.
Instances of this class are used to serialize or deserialize objects to or from an array of bytes.
A specific use of this class is that it can be loaded by a new classloader, making the execution transparent to any change in the client code.
A specific use of this class is that it can be loaded by a new classloader, making the execution transparent to any change in the client code.
A notification that can offload its user data to file to avoid OOMEs.
An execution policy rule that encapsulates a test of type property_value_or_expression is one of [value1, ··· , valueN].
Enumeration of the possible boolean operators that can be used as a comparison predicates for integer/long values.
Instances of this class wrap a singleton
SystemInfo object, which is the entry point for the
Oshi API.This interface represents an abstraction of any destination for outgoing data.
Redirect
System.out.println() calls to an SLF4J-based logger.This callback throws an IOException whenever the cumulated size of the data
written to a stream exceeds
Integer.MAX_VALUE.Utility class holding a pair of references to two objects.
A password source which uses a base64-encoded string stored in a file
Instances of this class represent the configuration parameters for a specific IP address pattern implementation.
Abstract superclass for custom peer driver discovery mechanisms in JPPF drivers.
Each instance of this class acts as a container for the performance data related to a node.
This is a utility class to be used to store the pair of mean and the
number of samples this mean is based on.
This MBean manages jobs persisted by the driver.
This interface represents the objects that are persisted in a job persistence store.
Implementation of the
PersistenceInfo interface.Instances of this class represent a key in the cache.
An enumeration of the possible types of objects or job elements that are persisted.
This class defines whether a job should be persisted and the behavior of the persistence facility upon recovery.
This interface is implemented by load-balancers that wish to persist their state.
Instances of this class represent a data frame read asynchronously from an input source.
A password source which uses a plain text string
Task wrapper for POJO classes.
Instances of this class provide contextual information to execution policies.
This class is a parser for XML Execution Policy documents.
Utility methods to resolve, parse and manipulate execution policies.
Interface representig an object that cn be accessed by its position in an ordered set.
A policy which evaluates a set of policies ordered by preference.
This class holds the constant for actions handled by a
LauncherListenerProtocolHandler.This class is intended as a controller for a subprocess, to enable stopping and restarting it when requested.
Instances of this class represent notifications that a slave process was started or terminated.
Listener interface that must be implemented by all classes wishing
to receive notifications of when a node is started or stopped.
Wrapper around an external process started with
ProcessBuilder.Instances of this class encapsulate an event occurring when a process writes to
its output or error stream.
Listener interface for receiving event notifications from a process wrapper.
A grouping of
TypedProperties objects, representing multiple sets of properties while allowing to retrive vlaues as if it were a single set of properties.This class loads and resolves the includes in a configuration file or source.
Abstract class for formatters that print the contents of a
Properties object as a string.A special type or expression that represents either the name of a property or an expression that resolves to a specified target type.
Enumeration of possible properties types.
This bundler implementation computes bundle sizes proportional to the mean execution
time for each node to the power of n, where n is an integer value specified in the configuration file as "proportionality factor".
The scope of this bundler is all nodes, which means that it computes the size for all nodes.
The mean execution time is computed as a moving average over a number of tasks, specified in the bundling algorithm profile configuration as "minSamplesToAnalyse"
This algorithm is well suited for relatively small networks (a few dozen nodes at most).
The scope of this bundler is all nodes, which means that it computes the size for all nodes.
The mean execution time is computed as a moving average over a number of tasks, specified in the bundling algorithm profile configuration as "minSamplesToAnalyse"
This algorithm is well suited for relatively small networks (a few dozen nodes at most).
Provider implementation for the "proportional" load-balancing algorithm.
Parameters profile for a proportional bundler.
Instances of this class represent
JPPFQueue events.Instances of this class handle an optionally bounded queue of elements.
Builder class for
QueueHandler instances.An operation applied to each element taken from the queue by the dequeuer thread(s).
Callback invoked when a new peak queue size is reached.
Queue listener interface.
Queue listener adapter, providing no-op implemzntations for the
QueueListener interface methods.Instances of this class represent a range of values.
Represents a pattern used for IP addresses inclusion or exclusion lists.
A pattern represents a single value or a range of values for each component of an IP address.
A pattern represents a single value or a range of values for each component of an IP address.
Collection of utility methods to facilitate the use of reflection.
Collection of static utility methods for dealing with reflection-based APIs.
Performs a regular expression match on either a job name or a job metadata value specified by its key.
An execution policy rule that encapsulates a test of type property_value matches regular_expression.
This class provides a set of utility methods for manipulating regular expressions,
along with a set of pre-compiled common regular expressions.
An execution policy rule that rejects everything.
Future for handling class loading requests.
An enumeration of the possible keys in a
JPPFResourceWrapper data map.Instances of this interface are dedicated to reading resource files form the JVM's classpath and converting them into arrays of bytes.
Instances of this class are dedicated to reading resource files form the JVM's classpath and converting them into arrays of bytes.
This class provides convenient methods to inspect and access a mapping of
InvocationResult instances to specified keys.Utility methods for retrying a callback that throws an exception, until it succeeds or
either a maximum number of attempts is reached or a timeout expires.
Bundler based on a reinforcement learning algorithm.
Provider implementation for the reinforcement learning load-balancing algorithm.
Parameters profile for the "rl2" algorithm.
Task wrapper for classes implementing
Runnable.This utility generates the doc-source php files for the samples pack from the readme in each sample.
Utility class to validate an XML document against an XML schema.
An easy to use wrapper around the JPPF scripting APIs.
A job selector that uses a script to accept jobs.
A node selector that uses a script to accept nodes.
A policy which executes an aribtrary script in its
accepts() method.A task implementation which executes a script in a specified JSR 223 (
javax.script APIs) script language.Handles the properties whose value contains one or more expressions of the form:
Common interface for all script runners, allowing access to a scripting engine.
Factory used to instantiate script runners.
Selector interface.
Synchronization aid for a
Selector, to prevent SelectionKey.interestOps(int) invocations from blocking for too long.Synchronization aid for a
Selector, to prevent SelectionKey.interestOps(int) invocations from blocking for too long.Synchronization aid for a
Selector, to prevent SelectionKey.interestOps(int) invocations from blocking for too long.COnstantqs used to specify or retrieve the strategy for sending results back to clients.
Collection of utility methods for serializing and deserializing to and from bytes buffers.
Collection of utility methods for serializing and deserializing to and from bytes buffers.
Exception raised when an attempt to serialize an object results in an array of bytes (or file) larger than
Integer.MAX_VALUE.This helper class provides utility methods to facilitate the JPPF-sepcific serialization and deserilaization.
Utility methods for serializing and deserializing data
Implementations of this interface provide environment properties to add to or override those passed to
JMXConnectorServerFactory.newJMXConnectorServer() when the a remote connector server is started.Instances of this class provide information about tasks that were dispatched to a node,
at the time they are returned from the node.
Instances of this class look for and find services implemented via the Service Provider Interface (SPI).
A utility class that handles a SPI mechanism.
A hash map whose values are sets of a specified component type.
An identity map whose values are sets of a specified component type.
A sorted map whose values are sets of a given component type.
An
NioMessage that reads or writes a single object.Instances of this class simply accumulate the values provided via calls to
SingleValueSnapshot.addValues(double, long).This SocketWrapper implementation relies on an underlying SocketChannel, in order to allow
writing to, and reading from, at the same time from the same socket connection.
This class provides a simple API to transfer objects over a TCP socket connection.
Common interface for objects that establish a connection with a remote socket.
Factory class for
SocketInitializers.This interface is common to all classes wrapping an underlying socket connections.
The underlying socket API can be either based on a socket channel (blocking or non-blocking), or just based on a plain socket.
The underlying socket API can be either based on a socket channel (blocking or non-blocking), or just based on a plain socket.
Input source backed by a
SocketWrapper.Output destination backed by a
SocketWrapper.Map whose values are soft references.
A sorted map whose values are sorted sets of a given component type.
This class encapsulates a Java platform compiler and provides an API to compile
java sources provided as string to either the file system or an in-memory location.
This exception is thrown when a problem is detected while loading the SSL configuration.
Wrapper for an
SSLEngine and an associated channel.Wrapper for an
SSLEngine and an associated channel.Utility class handling all aspects of the SSL configuration.
Utility class handling all aspects of the SSL configuration.
Utility class handling all aspects of the SSL configuration.
Implementation of
NioObject for reading or writing data from or to an SSL channel.nformation about a frame in a thread stack trace.
An action ot execute on a context.
Interface for context filtering.
A fuctional interface wrapping an operation on a set of selected channels.
Generates a PHP status page for Jenkins build results
Input source that takes an input stream as its source.
Output destination backed by an
OutputStream.Collection of utility methods for manipulating streams.
Implementation of
JPPFProperty for properties whose value is an array of Strings.An expression that represents a string as either a literal or an expression that returns a string.
Implementation of
JPPFProperty for String properties.This class provides a set of utility methods for manipulating strings.
Handles property substitutions in a properties file, that is resolve all.
A boolean value on which a set of operations can be performed atomically.
A ByteBuffer pool backed by a
LinkedList.An integer value on which a set of operations can be performed atomically.
A
ConcurrentHashMap whose values are CopyOnWriteArrayList instances.A long value on which a set of operations can be performed atomically.
An
Object value on which a set of operations can be performed atomically.Collection of utility methods used as a convenience for retrieving
JVM-level or System-level information.
Interface for all tasks submitted to the execution server.
Interface for job headers sent ver the network.
Instances of this class represent events that occur during the life span of an individual JPPF task.
Interface for all classes that wish to listen to events occurring during the life span of individual JPPF tasks.
Notification sent to provide information about a task that was executed in a node.
A graph of the tasks in a job, representing the "depends on" relationships between tasks.
A node in the graph of the tasks in a job which represents a task and its dependants.
Utility and factory methods to build and manipulate graphs of tasks.
Information about the task graph, if any, for a job.
Instances of this class encapsulate runtime information on tasks executed by a node.
Interface for tasks that are part of a dependency graph of tasks within a job.
Dependencies can be added using the
Dependencies can be added using the
dependsOn(Collection<TaskNode>) and dependsOn(TaskNode...) methods.Visitor interface for a graph of tasks with dependencies.
Enumeration of the possible outcomes (other than exceptions) of the visit of a node in a graph of tasks.
Wrapper interface for tasks that are not implementations of
Task.Type-safe enumeration for the type of method to execute.
State for task indicating whether result or exception was received.
Instances of this class hold a temporary
File and ensure the file
is deleted when they are garbage collected.Utility class that splits a text file into smaller ones with the same number of lines.
Formatter that print the contents of a
Properties object as a plain-text string.This class prints a thread dump nicely formatted as plain text to a character stream.
This class encapsulates a JVM thread dump, including deadlocks information when available.
Interface for printing a
ThreadDump.Information about a thread, including the stack trace and associated locks.
Interface for all thread managers.
Helper class for managing used class loaders.
This class manages the fork join pool for the node's execution manager.
This class manages the thread pool pool for the node's execution manager.
This class implements a goToSleep and a wakeUp method as wrappers to
Object.wait() and
Object.notifyAll() wrappers.Utility methods for creating, starting and manipulating threads.
Instances of this class generate thumbnails from a set of images stored in a file system folder.
File filter that only accepts files with specified extensions.
A simple utility class to measure the elapsed time between two points in the code.
This interface should be implemented by tasks that wish a callback invoked as soon
as they timeout.
Instances of this class are scheduled by a timer to execute one time, check
whether the corresponding JPPF task timeout has been reached, and abort the
task if necessary.
Tornament slection implemntation.
A list that maintains and manages a current position and corresponding current element.
Extension of the
java.util.Properties class to handle the conversion of string values to other types.A filter for
TypedProperties objects.Computes a similarity score between two instances of TypedProperties.
Deprecated.
this class is no longer useful, use its superclass
TypedProperties instead.Wrapper for manipulating data from a URL.
Selects nodes based on their uuids.
An enumeration of the possible types of values to which an execution policy rule may apply.
A specfic serialization handler for
Vector.This class provides a utility method to determine the JPPF build number available in the class path.
It is used for the nodes to determine when their code is outdated, in which case they will automatically reload their own code.
It is used for the nodes to determine when their code is outdated, in which case they will automatically reload their own code.
Describes the available version information.
Converts the JPPF predefined properties into the "Configuration properties reference" section of the doc as wiki text.
Visits the JPPF MBean in a remote JVM and generates a reference documentation page in wikimedia format.
This implementation uses the Xstream serialization library.
A composite serialization scheme which applies a ZLIB compression/decompression to a concrete
JPPFSerialization implementation.
NodeForwardingMBeaninsead.