Package akka.cluster.sharding.typed

Class SliceRangeShardAllocationStrategy

java.lang.Object

akka.cluster.sharding.typed.SliceRangeShardAllocationStrategy

All Implemented Interfaces:

NoSerializationVerificationNeeded, ClusterShardAllocationMixin, ShardCoordinator.ActorSystemDependentAllocationStrategy, ShardCoordinator.ShardAllocationStrategy

public class SliceRangeShardAllocationStrategy
extends java.lang.Object
implements ShardCoordinator.ActorSystemDependentAllocationStrategy, ClusterShardAllocationMixin

Intended to be used with database sharding, https://doc.akka.io/libraries/akka-persistence-r2dbc/current/data-partition.html, with a cluster of many Akka nodes. To avoid that each Akka node has database connections to all databases it is preferred to collocate entities with the same slice and contiguous range of slices to the same Akka node. Thereby the connections from one Akka node will go to one or a few databases since the database sharding is based on slice ranges.

It must be used together with the SliceRangeShardAllocationStrategy.ShardBySliceMessageExtractor.

Create a new instance of this for each entity type, i.e. a SliceRangeShardAllocationStrategy instance must not be shared between different entity types.

It will not rebalance when there is already an ongoing rebalance in progress.

Important: Do not change shard allocation strategy in a rolling update. The cluster must be fully stopped and then started again when changing to a different allocation strategy.

Not intended for public inheritance/implementation.

param: absoluteLimit the maximum number of shards that will be rebalanced in one rebalance round param: relativeLimit fraction (< 1.0) of total number of (known) shards that will be rebalanced in one rebalance round

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	SliceRangeShardAllocationStrategy.ShardBySliceMessageExtractor<M>	To be used together with SliceRangeShardAllocationStrategy.

Nested classes/interfaces inherited from interface akka.cluster.sharding.internal.ClusterShardAllocationMixin

ClusterShardAllocationMixin.RegionEntry, ClusterShardAllocationMixin.RegionEntry$, ClusterShardAllocationMixin.ShardSuitabilityOrdering, ClusterShardAllocationMixin.ShardSuitabilityOrdering$

Constructor Summary

Constructors

Constructor	Description
SliceRangeShardAllocationStrategy(int absoluteLimit, double relativeLimit)

Method Summary

Modifier and Type	Method	Description
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.
protected ClusterEvent.CurrentClusterState	clusterState()
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.
protected Member	selfMember()
void	start(ActorSystem system)	Called before any calls to allocate/rebalance.

Methods inherited from class java.lang.Object

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

Methods inherited from interface akka.cluster.sharding.internal.ClusterShardAllocationMixin

isAGoodTimeToRebalance, regionEntriesFor

Constructor Detail

SliceRangeShardAllocationStrategy

public SliceRangeShardAllocationStrategy(int absoluteLimit,
                                         double relativeLimit)

Method Detail

start

public void start(ActorSystem system)

Description copied from interface: ShardCoordinator.ActorSystemDependentAllocationStrategy

Called before any calls to allocate/rebalance. Do not block. If asynchronous actions are required they can be started here and delay the Futures returned by allocate/rebalance.

Specified by:

start in interface ShardCoordinator.ActorSystemDependentAllocationStrategy

clusterState

protected ClusterEvent.CurrentClusterState clusterState()

Specified by:

clusterState in interface ClusterShardAllocationMixin

selfMember

protected Member selfMember()

Specified by:

selfMember in interface ClusterShardAllocationMixin

allocateShard

public 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

rebalance

public 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