Package com.hazelcast.spi

Provides interfaces/classes for the Hazelcast SPI for building distributed data structures and services.

See: Description

Interface Summary

Interface	Description
BackupAwareOperation	A BackupAwareOperation is an Operation to indicate then when a change is made, a BackupOperation is created to replicate the backup.
BackupOperation	When an BackupAwareOperation makes a change, the backups need to be replicated to other members (depending on the configuration and if change really happened).
BlockingOperation	An interface that can be implemented by an operation that can block.
CanCancelOperations	Implemented by a service that can cancel its operations.
ClientAwareService	A interface that can be implemented by a SPI Service so that it can be notified about client disconnects.
ConfigurableService<T>	A capability for SPI services.
CoreService	Marker interface for core Hazelcast services.
EventFilter	A predicate that can filter out events.
EventPublishingService<E,T>	A service for publishing events.
EventRegistration	The result of a Event Registration.
EventService	Component responsible for handling events like topic events or map.listener events.
ExecutionService	A Service responsible for providing access to 'system' executors and customer executors.
FragmentedMigrationAwareService	FragmentedMigrationAwareService is an extension to the MigrationAwareService which allows migration/replication of partition replicas in smaller fragments.
GracefulShutdownAwareService	An interface that can be implemented by SPI services to participate in graceful shutdown process, such as moving their internal data to another node or releasing their allocated resources gracefully.
InitializingObject	Can be implemented by DistributedObject (proxies) to indicate that they want to be initialized.
InternalCompletableFuture<E>	A ICompletableFuture with more functionality like getting the result without needing to deal with checked exceptions.
ListenerWrapperEventFilter	Contract point for EventFilter instances these wrap listeners.
LiveOperations	InvocationMonitor passes instances of this type to each LiveOperationsTracker so it can contribute the call IDs of invocations it is responsible for.
LiveOperationsTracker	Can be implemented by a Service to track live operations.
LockInterceptorService<T>	Interface to be implemented by services that need to intercept lock operation for distributed objects it manages.
ManagedService	An interface that can be implemented by an SPI Service to receive lifecycle calls: initialization shutdown reset
MemberAddressProvider	IMPORTANT This interface is not intended to provide addresses of other cluster members with which the hazelcast instance will form a cluster.
MembershipAwareService	An interface that can be implemented by a SPI service that needs to be notified members joining and leaving the cluster.
MigrationAwareService	An interface that can be implemented by SPI services to get notified of partition changes; for example, if a MapService starts moving its data around because partitions are moving to a different machine.
NamedOperation	Indicates that Operation carries the distributed data structure name that is going to work on.
NodeAware	A 'capability' that can be implemented by object to get the Node injected.
NodeEngine	The NodeEngine is the 'umbrella' of services/service-method that gets injected into a ManagedService.
NotifiableEventListener<S>	Contract point for event listeners to be notified by EventService.
Notifier	A component used in wait/notify systems like Condition.
ObjectNamespace	An ObjectNamespace that makes identification of object within a service possible.
OperationFactory	A Factory for creating Operation instances.
OperationResponseHandler<O extends Operation>	A handler for the OperationService when it has calculated a response.
OperationService	The OperationService is responsible for executing operations.
PartitionAwareOperation	An interface that can be implemented by an operation to indicate that it should be invoked on a particular partition.
PartitionAwareService	An interface that can be implemented by SPI services to get notified of when a partition-related event occurs; for example, if a MapService notifies its map listeners when partition is lost for a map.
PostJoinAwareService	Marker interface for services that want to return operations to be executed on the cluster members after a join has been finalized.
PreJoinAwareService	Services which need to perform operations on a joining member just before the member is set as joined must implement this interface.
ProxyService	A CoreService responsible for managing the DistributedObject proxies.
QuorumAwareService	Quorum service can ask for quorum information to the QuorumAwareService to decide whether operation participates into a quorum or not.
ReadonlyOperation	Read-only operations are allowed to run during migration and passive state.
RemoteService	An interface that can be implemented by SPI-Services to give them the ability to create proxies to distributed objects.
ReplicationSupportingService	An interface that can be implemented by SPI services to give them the ability to listen to WAN replication events.
ServiceConfigurationParser<T>	A hook into the parsing system.
ServiceNamespace	ServiceNamespace is a namespace to group objects, structures, fragments within a service.
ServiceNamespaceAware	An object which is aware of ServiceNamespace which object itself belongs to.
SharedService	Deprecated since 3.7.
SplitBrainHandlerService	An interface that can be implemented by SPI services that want to be able to resolve a split-brain.
StatisticsAwareService<T extends LocalInstanceStats>	A service implementating this interface provides local instance statistics.
TaskScheduler	ExecutorService can schedule a command to run after a given delay or execute periodically.
TransactionalService	An interface that can be implemented by SPI services that want to deal with transactions.
UrgentSystemOperation	An Marker interface that signals that an operation is an urgent System Operation.
WaitNotifyKey	A key for a wait notify object e.g.

Class Summary

Class	Description
AbstractDistributedObject<S extends RemoteService>	Abstract DistributedObject implementation.
AbstractLocalOperation	Abstract class for local operations, which should not be serializable.
AbstractWaitNotifyKey	Abstract implementation of the WaitNotifyKey.
CallsPerMember	Implements LiveOperations and additionally collects the call IDs of operations on remote members whose cancellation was requested.
CallStatus	The result of an Operation.call().
DefaultObjectNamespace	Deprecated please use DistributedObjectNamespace
DistributedObjectNamespace	Default ObjectNamespace implementation for DistributedObject.
InvocationBuilder	The InvocationBuilder is responsible for building an invocation of an operation and invoking it.
MemberAttributeServiceEvent	This service event is fired to inform services about a change in a member's attributes collection
MembershipServiceEvent	Membership event fired when a new member is added to the cluster and/or when a member leaves the cluster.
Offload	This is an internal class.
Operation	An operation could be compared to a Runnable.
OperationAccessor	Allows access to certain attributes on an Operation.
OperationControl	Content of an Operation Control packet: a list of operations the remote member started on this member which are still running; a list of operations this member wants to cancel on the remote member. Operations are identified by their call ID.
PartitionMigrationEvent	An EventObject for a partition migration.
PartitionReplicationEvent	An event send to MigrationAwareService when partition changes happen.
TransactionalDistributedObject<S extends RemoteService>	To centralize de-serialization for transactional proxies

Enum Summary

Enum	Description
ExceptionAction	The possible actions that can be taken when a certain exception is thrown.

Package com.hazelcast.spi Description

Provides interfaces/classes for the Hazelcast SPI for building distributed data structures and services. As a low-level API, it is expected to change in each release except for the patch releases.