org.apache.flink.runtime.rpc.akka

Class AkkaRpcService

java.lang.Object

org.apache.flink.runtime.rpc.akka.AkkaRpcService

All Implemented Interfaces:

RpcService

@ThreadSafe
public class AkkaRpcService
extends Object
implements RpcService

Akka based RpcService implementation. The RPC service starts an Akka actor to receive RPC invocations from a RpcGateway.

Constructor Summary

Constructors

Constructor and Description
AkkaRpcService(akka.actor.ActorSystem actorSystem, AkkaRpcServiceConfiguration configuration)

Method Summary

Modifier and Type	Method and Description
<C extends RpcGateway> CompletableFuture<C>	connect(String address, Class<C> clazz) Connect to a remote rpc server under the provided address.
<F extends Serializable,C extends FencedRpcGateway<F>> CompletableFuture<C>	connect(String address, F fencingToken, Class<C> clazz) Connect to a remote fenced rpc server under the provided address.
<T> CompletableFuture<T>	execute(Callable<T> callable) Execute the given callable and return its result as a CompletableFuture.
void	execute(Runnable runnable) Execute the given runnable in the executor of the RPC service.
<F extends Serializable> RpcServer	fenceRpcServer(RpcServer rpcServer, F fencingToken) Fence the given RpcServer with the given fencing token.
akka.actor.ActorSystem	getActorSystem()
String	getAddress() Return the hostname or host address under which the rpc service can be reached.
Executor	getExecutor() Gets the executor, provided by this RPC service.
int	getPort() Return the port under which the rpc service is reachable.
ScheduledExecutor	getScheduledExecutor() Gets a scheduled executor from the RPC service.
CompletableFuture<Void>	getTerminationFuture() Returns a future indicating when the RPC service has been shut down.
protected int	getVersion()
ScheduledFuture<?>	scheduleRunnable(Runnable runnable, long delay, TimeUnit unit) Execute the runnable in the execution context of this RPC Service, as returned by RpcService.getExecutor(), after a scheduled delay.
<C extends RpcEndpoint & RpcGateway> RpcServer	startServer(C rpcEndpoint) Start a rpc server which forwards the remote procedure calls to the provided rpc endpoint.
void	stopServer(RpcServer selfGateway) Stop the underlying rpc server of the provided self gateway.
CompletableFuture<Void>	stopService() Trigger the asynchronous stopping of the RpcService.

Methods inherited from class java.lang.Object

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

Constructor Detail

AkkaRpcService

@VisibleForTesting
public AkkaRpcService(akka.actor.ActorSystem actorSystem,
                                         AkkaRpcServiceConfiguration configuration)

Method Detail

getActorSystem

public akka.actor.ActorSystem getActorSystem()

getVersion

protected int getVersion()

getAddress

public String getAddress()

Description copied from interface: RpcService

Return the hostname or host address under which the rpc service can be reached. If the rpc service cannot be contacted remotely, then it will return an empty string.

Specified by:

getAddress in interface RpcService

Returns:

Address of the rpc service or empty string if local rpc service

getPort

public int getPort()

Description copied from interface: RpcService

Return the port under which the rpc service is reachable. If the rpc service cannot be contacted remotely, then it will return -1.

Specified by:

getPort in interface RpcService

Returns:

Port of the rpc service or -1 if local rpc service

connect

public <C extends RpcGateway> CompletableFuture<C> connect(String address,
                                                           Class<C> clazz)

Description copied from interface: RpcService

Connect to a remote rpc server under the provided address. Returns a rpc gateway which can be used to communicate with the rpc server. If the connection failed, then the returned future is failed with a RpcConnectionException.

Specified by:

connect in interface RpcService

Type Parameters:

C - Type of the rpc gateway to return

Parameters:

address - Address of the remote rpc server

clazz - Class of the rpc gateway to return

Returns:

Future containing the rpc gateway or an RpcConnectionException if the connection attempt failed

connect

public <F extends Serializable,C extends FencedRpcGateway<F>> CompletableFuture<C> connect(String address,
                                                                                           F fencingToken,
                                                                                           Class<C> clazz)

Description copied from interface: RpcService

Connect to a remote fenced rpc server under the provided address. Returns a fenced rpc gateway which can be used to communicate with the rpc server. If the connection failed, then the returned future is failed with a RpcConnectionException.

Specified by:

connect in interface RpcService

Type Parameters:

F - Type of the fencing token

C - Type of the rpc gateway to return

Parameters:

address - Address of the remote rpc server

fencingToken - Fencing token to be used when communicating with the server

clazz - Class of the rpc gateway to return

Returns:

Future containing the fenced rpc gateway or an RpcConnectionException if the connection attempt failed

startServer

public <C extends RpcEndpoint & RpcGateway> RpcServer startServer(C rpcEndpoint)

Description copied from interface: RpcService

Start a rpc server which forwards the remote procedure calls to the provided rpc endpoint.

Specified by:

startServer in interface RpcService

Type Parameters:

C - Type of the rpc endpoint

Parameters:

rpcEndpoint - Rpc protocol to dispatch the rpcs to

Returns:

Self gateway to dispatch remote procedure calls to oneself

fenceRpcServer

public <F extends Serializable> RpcServer fenceRpcServer(RpcServer rpcServer,
                                                         F fencingToken)

Description copied from interface: RpcService

Fence the given RpcServer with the given fencing token.

Fencing the RpcServer means that we fix the fencing token to the provided value. All RPCs will then be enriched with this fencing token. This expects that the receiving RPC endpoint extends FencedRpcEndpoint.

Specified by:

fenceRpcServer in interface RpcService

Type Parameters:

F - type of the fencing token

Parameters:

rpcServer - to fence with the given fencing token

fencingToken - to fence the RpcServer with

Returns:

Fenced RpcServer

stopServer

public void stopServer(RpcServer selfGateway)

Description copied from interface: RpcService

Stop the underlying rpc server of the provided self gateway.

Specified by:

stopServer in interface RpcService

Parameters:

selfGateway - Self gateway describing the underlying rpc server

stopService

public CompletableFuture<Void> stopService()

Description copied from interface: RpcService

Trigger the asynchronous stopping of the RpcService.

Specified by:

stopService in interface RpcService

Returns:

Future which is completed once the RpcService has been fully stopped.

getTerminationFuture

public CompletableFuture<Void> getTerminationFuture()

Description copied from interface: RpcService

Returns a future indicating when the RPC service has been shut down.

Specified by:

getTerminationFuture in interface RpcService

Returns:

Termination future

getExecutor

public Executor getExecutor()

Description copied from interface: RpcService

Gets the executor, provided by this RPC service. This executor can be used for example for the handleAsync(...) or thenAcceptAsync(...) methods of futures.

IMPORTANT: This executor does not isolate the method invocations against any concurrent invocations and is therefore not suitable to run completion methods of futures that modify state of an RpcEndpoint. For such operations, one needs to use the MainThreadExecutionContext of that RpcEndpoint.

Specified by:

getExecutor in interface RpcService

Returns:

The execution context provided by the RPC service

getScheduledExecutor

public ScheduledExecutor getScheduledExecutor()

Description copied from interface: RpcService

Gets a scheduled executor from the RPC service. This executor can be used to schedule tasks to be executed in the future.

IMPORTANT: This executor does not isolate the method invocations against any concurrent invocations and is therefore not suitable to run completion methods of futures that modify state of an RpcEndpoint. For such operations, one needs to use the MainThreadExecutionContext of that RpcEndpoint.

Specified by:

getScheduledExecutor in interface RpcService

Returns:

The RPC service provided scheduled executor

scheduleRunnable

public ScheduledFuture<?> scheduleRunnable(Runnable runnable,
                                           long delay,
                                           TimeUnit unit)

Description copied from interface: RpcService

Execute the runnable in the execution context of this RPC Service, as returned by RpcService.getExecutor(), after a scheduled delay.

Specified by:

scheduleRunnable in interface RpcService

Parameters:

runnable - Runnable to be executed

delay - The delay after which the runnable will be executed

execute

public void execute(Runnable runnable)

Description copied from interface: RpcService

Execute the given runnable in the executor of the RPC service. This method can be used to run code outside of the main thread of a RpcEndpoint.

IMPORTANT: This executor does not isolate the method invocations against any concurrent invocations and is therefore not suitable to run completion methods of futures that modify state of an RpcEndpoint. For such operations, one needs to use the MainThreadExecutionContext of that RpcEndpoint.

Specified by:

execute in interface RpcService

Parameters:

runnable - to execute

execute

public <T> CompletableFuture<T> execute(Callable<T> callable)

Description copied from interface: RpcService

Execute the given callable and return its result as a CompletableFuture. This method can be used to run code outside of the main thread of a RpcEndpoint.

IMPORTANT: This executor does not isolate the method invocations against any concurrent invocations and is therefore not suitable to run completion methods of futures that modify state of an RpcEndpoint. For such operations, one needs to use the MainThreadExecutionContext of that RpcEndpoint.

Specified by:

execute in interface RpcService

Type Parameters:

T - is the return value type

Parameters:

callable - to execute

Returns:

Future containing the callable's future result