Package akka.cluster.sharding.external

Class ExternalShardAllocationStrategy

java.lang.Object

akka.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
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)	Scala API
static ExternalShardAllocationStrategy	create(ClassicActorSystemProvider systemProvider, java.lang.String typeName)	Java API
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

apply

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

Scala API

create

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

Java API

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