class SliceRangeShardAllocationStrategy extends ActorSystemDependentAllocationStrategy with 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.

Annotations
@DoNotInherit()
Source
SliceRangeShardAllocationStrategy.scala
Linear Supertypes
ClusterShardAllocationMixin, ActorSystemDependentAllocationStrategy, ShardAllocationStrategy, NoSerializationVerificationNeeded, AnyRef, Any
Type Hierarchy
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SliceRangeShardAllocationStrategy
  2. ClusterShardAllocationMixin
  3. ActorSystemDependentAllocationStrategy
  4. ShardAllocationStrategy
  5. NoSerializationVerificationNeeded
  6. AnyRef
  7. Any
Implicitly
  1. by any2stringadd
  2. by StringFormat
  3. by Ensuring
  4. by ArrowAssoc
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new SliceRangeShardAllocationStrategy(absoluteLimit: Int, relativeLimit: Double)

    absoluteLimit

    the maximum number of shards that will be rebalanced in one rebalance round

    relativeLimit

    fraction (< 1.0) of total number of (known) shards that will be rebalanced in one rebalance round

Value Members

  1. def allocateShard(requester: ActorRef, shardId: ShardId, currentShardAllocations: Map[ActorRef, IndexedSeq[ShardId]]): [ActorRef]

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

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

    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

    Definition Classes
    → ShardAllocationStrategy
  2. def rebalance(currentShardAllocations: Map[ActorRef, IndexedSeq[ShardId]], rebalanceInProgress: Set[ShardId]): Future[Set[ShardId]]

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

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

    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

    Definition Classes
    → ShardAllocationStrategy
  3. def start(system: ActorSystem): Unit

    Called before any calls to allocate/rebalance.

    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.

    Definition Classes
    SliceRangeShardAllocationStrategy → ActorSystemDependentAllocationStrategy