Package akka.cluster.sharding

Class ShardCoordinator.AbstractShardAllocationStrategy

java.lang.Object

akka.cluster.sharding.ShardCoordinator.AbstractShardAllocationStrategy

All Implemented Interfaces:

NoSerializationVerificationNeeded, ShardCoordinator.ShardAllocationStrategy

Enclosing class:

ShardCoordinator

public abstract static class ShardCoordinator.AbstractShardAllocationStrategy
extends java.lang.Object
implements ShardCoordinator.ShardAllocationStrategy

Java API: Java implementations of custom shard allocation and rebalancing logic used by the ShardCoordinator should extend this abstract class and override allocateNewShard(akka.actor.ActorRef,java.lang.String,java.util.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>) and rebalanceShard.

Earlier versions of this API had different extension points. Overriding those is still supported but they may be removed in a future release.

Constructor Summary

Constructors

Constructor	Description
AbstractShardAllocationStrategy()

Method Summary

Modifier and Type	Method	Description
java.util.concurrent.CompletionStage<ActorRef>	allocateNewShard(ActorRef requester, java.lang.String shardId, java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)	Invoked when the location of a new shard is to be decided.
scala.concurrent.Future<ActorRef>	allocateShard(ActorRef requester, java.lang.String shardId, java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)	Deprecated. prefer allocateNewShard.
scala.concurrent.Future<ActorRef>	allocateShard(ActorRef requester, java.lang.String shardId, scala.collection.immutable.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)	Invoked when the location of a new shard is to be decided.
scala.concurrent.Future<java.util.Set<java.lang.String>>	rebalance(java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations, java.util.Set<java.lang.String> rebalanceInProgress)	Deprecated. prefer rebalanceShards.
scala.concurrent.Future<scala.collection.immutable.Set<java.lang.String>>	rebalance(scala.collection.immutable.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations, scala.collection.immutable.Set<java.lang.String> rebalanceInProgress)	Invoked periodically to decide which shards to rebalance to another location.
java.util.concurrent.CompletionStage<java.util.Set<java.lang.String>>	rebalanceShards(java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations, java.util.Set<java.lang.String> rebalanceInProgress)	Invoked periodically to decide which shards to rebalance to another location.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AbstractShardAllocationStrategy

public AbstractShardAllocationStrategy()

Method Detail

allocateNewShard

public java.util.concurrent.CompletionStage<ActorRef> allocateNewShard(ActorRef requester,
                                                                       java.lang.String shardId,
                                                                       java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)

Invoked when the location of a new shard is to be decided.

New implementations of this class should override this method instead of overriding allocateShard(akka.actor.ActorRef,java.lang.String,scala.collection.immutable.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>).

For compatibility with earlier versions of this API, this method's default implementation returns an immediately-failing CompletionStage.

Parameters:

requester - actor reference to the ShardRegion that requested the location of the shard, can be returned if preference should be given to the node where the shard was first accessed

shardId - the id of the shard to allocate

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

Returns:

a CompletionStage of the actor ref of the ShardRegion that is to be responsible for the shard, must be one of the references included in the currentShardAllocations parameter

allocateShard

public final scala.concurrent.Future<ActorRef> allocateShard(ActorRef requester,
                                                             java.lang.String shardId,
                                                             scala.collection.immutable.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)

Description copied from interface: ShardCoordinator.ShardAllocationStrategy

Invoked when the location of a new shard is to be decided.

Specified by:

allocateShard in interface ShardCoordinator.ShardAllocationStrategy

Parameters:

requester - actor reference to the ShardRegion that requested the location of the shard, can be returned if preference should be given to the node where the shard was first accessed

shardId - the id of the shard to allocate

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

Returns:

a Future of the actor ref of the ShardRegion that is to be responsible for the shard, must be one of the references included in the currentShardAllocations parameter

allocateShard

public scala.concurrent.Future<ActorRef> allocateShard(ActorRef requester,
                                                       java.lang.String shardId,
                                                       java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations)

Deprecated.

prefer allocateNewShard. Since 2.10.10.

Invoked when the location of a new shard is to be decided.

The default implementation defers to allocateNewShard(akka.actor.ActorRef,java.lang.String,java.util.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>). In earlier versions of this API, this Scala Future-returning method was the extension point.

New implementations of this class should prefer to override allocateNewShard(akka.actor.ActorRef,java.lang.String,java.util.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>). This method may be removed in a future release.

Parameters:

requester - actor reference to the ShardRegion that requested the location of the shard, can be returned if preference should be given to the node where the shard was first accessed

shardId - the id of the shard to allocate

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

Returns:

a Future of the actor ref of the ShardRegion that is to be responsible for the shard, must be one of the references included in the currentShardAllocations parameter

rebalance

public final scala.concurrent.Future<scala.collection.immutable.Set<java.lang.String>> rebalance(scala.collection.immutable.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations,
                                                                                                 scala.collection.immutable.Set<java.lang.String> rebalanceInProgress)

Description copied from interface: ShardCoordinator.ShardAllocationStrategy

Invoked periodically to decide which shards to rebalance to another location.

Specified by:

rebalance in interface ShardCoordinator.ShardAllocationStrategy

Parameters:

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

rebalanceInProgress - set of shards that are currently being rebalanced, i.e. you should not include these in the returned set

Returns:

a Future of the shards to be migrated, may be empty to skip rebalance in this round

rebalance

public scala.concurrent.Future<java.util.Set<java.lang.String>> rebalance(java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations,
                                                                          java.util.Set<java.lang.String> rebalanceInProgress)

Deprecated.

prefer rebalanceShards. Since 2.10.10.

Invoked periodically to decide which shards to rebalance to another location.

The default implementation defers to rebalanceShards(java.util.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>,java.util.Set<java.lang.String>). In earlier versions of this API, this Scala Future-returning method was the extension point.

New implementations of this class should prefer to override rebalanceShards(java.util.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>,java.util.Set<java.lang.String>). This method may be removed in a future release

Parameters:

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

rebalanceInProgress - set of shards that are currently being rebalanced, i.e. you should not include these in the returned set

Returns:

a Future of the shards to be migrated, may be empty to skip rebalance in this round

rebalanceShards

public java.util.concurrent.CompletionStage<java.util.Set<java.lang.String>> rebalanceShards(java.util.Map<ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>> currentShardAllocations,
                                                                                             java.util.Set<java.lang.String> rebalanceInProgress)

Invoked periodically to decide which shards to rebalance to another location.

New implementations of this class should override this method instead of overriding rebalance(scala.collection.immutable.Map<akka.actor.ActorRef,scala.collection.immutable.IndexedSeq<java.lang.String>>,scala.collection.immutable.Set<java.lang.String>).

For compatibility with earlier versions of this API, this method's default implementation returns an immediately-failing CompletionStage.

Parameters:

currentShardAllocations - all actor refs to ShardRegion and their current allocated shards, in the order they were allocated

rebalanceInProgress - set of shards that are currently being rebalanced, i.e. you should not include these in the returned set

Returns:

a CompletionStage of the set of shards to be migrated, may be empty to skip rebalance in this round