Package org.apache.pekko.cluster.sharding.external

Class ExternalShardAllocationStrategy

java.lang.Object

org.apache.pekko.cluster.sharding.external.ExternalShardAllocationStrategy

All Implemented Interfaces:

NoSerializationVerificationNeeded, ShardCoordinator.ShardAllocationStrategy, ShardCoordinator.StartableAllocationStrategy

public class ExternalShardAllocationStrategy
extends java.lang.Object
implements ShardCoordinator.StartableAllocationStrategy

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ExternalShardAllocationStrategy.GetShardLocation$
static class	ExternalShardAllocationStrategy.GetShardLocationResponse$
static class	ExternalShardAllocationStrategy.GetShardLocations$
static class	ExternalShardAllocationStrategy.GetShardLocationsResponse$
static class	ExternalShardAllocationStrategy.ShardLocation
static class	ExternalShardAllocationStrategy.ShardLocation$

Constructor Summary

Constructors

Constructor	Description
ExternalShardAllocationStrategy(ClassicActorSystemProvider systemProvider, java.lang.String typeName, Timeout timeout)

Method Summary

Modifier and Type	Method	Description
static Timeout	$lessinit$greater$default$3(ClassicActorSystemProvider systemProvider, java.lang.String typeName)	Java API: Create an ExternalShardAllocationStrategy
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.
static ExternalShardAllocationStrategy	apply(ClassicActorSystemProvider systemProvider, java.lang.String typeName)	Create an ExternalShardAllocationStrategy
static ExternalShardAllocationStrategy	apply(ClassicActorSystemProvider systemProvider, java.lang.String typeName, scala.concurrent.duration.FiniteDuration timeout)	Scala API: Create an ExternalShardAllocationStrategy
static ExternalShardAllocationStrategy	create(ClassicActorSystemProvider systemProvider, java.lang.String typeName, java.time.Duration timeout)	Java API: Create an ExternalShardAllocationStrategy
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.
void	start()	Called before any calls to allocate/rebalance.
Timeout	timeout()

Methods inherited from class java.lang.Object

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

Constructor Detail

ExternalShardAllocationStrategy

public ExternalShardAllocationStrategy(ClassicActorSystemProvider systemProvider,
                                       java.lang.String typeName,
                                       Timeout timeout)

Method Detail

$lessinit$greater$default$3

public static Timeout $lessinit$greater$default$3(ClassicActorSystemProvider systemProvider,
                                                  java.lang.String typeName)

Java API: Create an ExternalShardAllocationStrategy

apply

public static ExternalShardAllocationStrategy apply(ClassicActorSystemProvider systemProvider,
                                                    java.lang.String typeName)

Create an ExternalShardAllocationStrategy

apply

public static ExternalShardAllocationStrategy apply(ClassicActorSystemProvider systemProvider,
                                                    java.lang.String typeName,
                                                    scala.concurrent.duration.FiniteDuration timeout)

Scala API: Create an ExternalShardAllocationStrategy

create

public static ExternalShardAllocationStrategy create(ClassicActorSystemProvider systemProvider,
                                                     java.lang.String typeName,
                                                     java.time.Duration timeout)

Java API: Create an ExternalShardAllocationStrategy

timeout

public Timeout timeout()

start

public void start()

Description copied from interface: ShardCoordinator.StartableAllocationStrategy

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.StartableAllocationStrategy

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