Class 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

    • Constructor Detail

      • SliceRangeShardAllocationStrategy

        public SliceRangeShardAllocationStrategy​(int absoluteLimit,
                                                 double relativeLimit)
    • Method Detail

      • 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