org.apache.flink.runtime.rpc.RpcServer Java Examples

@Override
public <F extends Serializable> RpcServer fenceRpcServer(RpcServer rpcServer, F fencingToken) {
	if (rpcServer instanceof AkkaBasedEndpoint) {

		InvocationHandler fencedInvocationHandler = new FencedAkkaInvocationHandler<>(
			rpcServer.getAddress(),
			rpcServer.getHostname(),
			((AkkaBasedEndpoint) rpcServer).getActorRef(),
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			null,
			() -> fencingToken);

		// Rather than using the System ClassLoader directly, we derive the ClassLoader
		// from this class . That works better in cases where Flink runs embedded and all Flink
		// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
		ClassLoader classLoader = getClass().getClassLoader();

		return (RpcServer) Proxy.newProxyInstance(
			classLoader,
			new Class<?>[]{RpcServer.class, AkkaBasedEndpoint.class},
			fencedInvocationHandler);
	} else {
		throw new RuntimeException("The given RpcServer must implement the AkkaGateway in order to fence it.");
	}
}
 

@Override
public void stopServer(RpcServer selfGateway) {
	if (selfGateway instanceof AkkaBasedEndpoint) {
		final AkkaBasedEndpoint akkaClient = (AkkaBasedEndpoint) selfGateway;
		final RpcEndpoint rpcEndpoint;

		synchronized (lock) {
			if (stopped) {
				return;
			} else {
				rpcEndpoint = actors.remove(akkaClient.getActorRef());
			}
		}

		if (rpcEndpoint != null) {
			terminateAkkaRpcActor(akkaClient.getActorRef(), rpcEndpoint);
		} else {
			LOG.debug("RPC endpoint {} already stopped or from different RPC service", selfGateway.getAddress());
		}
	}
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	Class<?> declaringClass = method.getDeclaringClass();

	Object result;

	if (declaringClass.equals(AkkaBasedEndpoint.class) ||
		declaringClass.equals(Object.class) ||
		declaringClass.equals(RpcGateway.class) ||
		declaringClass.equals(StartStoppable.class) ||
		declaringClass.equals(MainThreadExecutable.class) ||
		declaringClass.equals(RpcServer.class)) {
		result = method.invoke(this, args);
	} else if (declaringClass.equals(FencedRpcGateway.class)) {
		throw new UnsupportedOperationException("AkkaInvocationHandler does not support the call FencedRpcGateway#" +
			method.getName() + ". This indicates that you retrieved a FencedRpcGateway without specifying a " +
			"fencing token. Please use RpcService#connect(RpcService, F, Time) with F being the fencing token to " +
			"retrieve a properly FencedRpcGateway.");
	} else {
		result = invokeRpc(method, args);
	}

	return result;
}
 

@Override
public <F extends Serializable> RpcServer fenceRpcServer(RpcServer rpcServer, F fencingToken) {
	if (rpcServer instanceof AkkaBasedEndpoint) {

		InvocationHandler fencedInvocationHandler = new FencedAkkaInvocationHandler<>(
			rpcServer.getAddress(),
			rpcServer.getHostname(),
			((AkkaBasedEndpoint) rpcServer).getActorRef(),
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			null,
			() -> fencingToken);

		// Rather than using the System ClassLoader directly, we derive the ClassLoader
		// from this class . That works better in cases where Flink runs embedded and all Flink
		// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
		ClassLoader classLoader = getClass().getClassLoader();

		return (RpcServer) Proxy.newProxyInstance(
			classLoader,
			new Class<?>[]{RpcServer.class, AkkaBasedEndpoint.class},
			fencedInvocationHandler);
	} else {
		throw new RuntimeException("The given RpcServer must implement the AkkaGateway in order to fence it.");
	}
}
 

@Override
public void stopServer(RpcServer selfGateway) {
	if (selfGateway instanceof AkkaBasedEndpoint) {
		final AkkaBasedEndpoint akkaClient = (AkkaBasedEndpoint) selfGateway;
		final RpcEndpoint rpcEndpoint;

		synchronized (lock) {
			if (stopped) {
				return;
			} else {
				rpcEndpoint = actors.remove(akkaClient.getActorRef());
			}
		}

		if (rpcEndpoint != null) {
			terminateAkkaRpcActor(akkaClient.getActorRef(), rpcEndpoint);
		} else {
			LOG.debug("RPC endpoint {} already stopped or from different RPC service", selfGateway.getAddress());
		}
	}
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	Class<?> declaringClass = method.getDeclaringClass();

	Object result;

	if (declaringClass.equals(AkkaBasedEndpoint.class) ||
		declaringClass.equals(Object.class) ||
		declaringClass.equals(RpcGateway.class) ||
		declaringClass.equals(StartStoppable.class) ||
		declaringClass.equals(MainThreadExecutable.class) ||
		declaringClass.equals(RpcServer.class)) {
		result = method.invoke(this, args);
	} else if (declaringClass.equals(FencedRpcGateway.class)) {
		throw new UnsupportedOperationException("AkkaInvocationHandler does not support the call FencedRpcGateway#" +
			method.getName() + ". This indicates that you retrieved a FencedRpcGateway without specifying a " +
			"fencing token. Please use RpcService#connect(RpcService, F, Time) with F being the fencing token to " +
			"retrieve a properly FencedRpcGateway.");
	} else {
		result = invokeRpc(method, args);
	}

	return result;
}
 

@Override
public void stopServer(RpcServer selfGateway) {
	if (selfGateway instanceof AkkaBasedEndpoint) {
		final AkkaBasedEndpoint akkaClient = (AkkaBasedEndpoint) selfGateway;
		final RpcEndpoint rpcEndpoint;

		synchronized (lock) {
			if (stopped) {
				return;
			} else {
				rpcEndpoint = actors.remove(akkaClient.getActorRef());
			}
		}

		if (rpcEndpoint != null) {
			terminateAkkaRpcActor(akkaClient.getActorRef(), rpcEndpoint);
		} else {
			LOG.debug("RPC endpoint {} already stopped or from different RPC service", selfGateway.getAddress());
		}
	}
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	Class<?> declaringClass = method.getDeclaringClass();

	Object result;

	if (declaringClass.equals(AkkaBasedEndpoint.class) ||
		declaringClass.equals(Object.class) ||
		declaringClass.equals(RpcGateway.class) ||
		declaringClass.equals(StartStoppable.class) ||
		declaringClass.equals(MainThreadExecutable.class) ||
		declaringClass.equals(RpcServer.class)) {
		result = method.invoke(this, args);
	} else if (declaringClass.equals(FencedRpcGateway.class)) {
		throw new UnsupportedOperationException("AkkaInvocationHandler does not support the call FencedRpcGateway#" +
			method.getName() + ". This indicates that you retrieved a FencedRpcGateway without specifying a " +
			"fencing token. Please use RpcService#connect(RpcService, F, Time) with F being the fencing token to " +
			"retrieve a properly FencedRpcGateway.");
	} else {
		result = invokeRpc(method, args);
	}

	return result;
}
 

@Override
public <F extends Serializable> RpcServer fenceRpcServer(RpcServer rpcServer, F fencingToken) {
	if (rpcServer instanceof AkkaBasedEndpoint) {

		InvocationHandler fencedInvocationHandler = new FencedAkkaInvocationHandler<>(
			rpcServer.getAddress(),
			rpcServer.getHostname(),
			((AkkaBasedEndpoint) rpcServer).getActorRef(),
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			null,
			() -> fencingToken,
			captureAskCallstacks);

		// Rather than using the System ClassLoader directly, we derive the ClassLoader
		// from this class . That works better in cases where Flink runs embedded and all Flink
		// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
		ClassLoader classLoader = getClass().getClassLoader();

		return (RpcServer) Proxy.newProxyInstance(
			classLoader,
			new Class<?>[]{RpcServer.class, AkkaBasedEndpoint.class},
			fencedInvocationHandler);
	} else {
		throw new RuntimeException("The given RpcServer must implement the AkkaGateway in order to fence it.");
	}
}
 

@Override
public <C extends RpcEndpoint & RpcGateway> RpcServer startServer(C rpcEndpoint) {
	checkNotNull(rpcEndpoint, "rpc endpoint");

	CompletableFuture<Void> terminationFuture = new CompletableFuture<>();
	final Props akkaRpcActorProps;

	if (rpcEndpoint instanceof FencedRpcEndpoint) {
		akkaRpcActorProps = Props.create(
			FencedAkkaRpcActor.class,
			rpcEndpoint,
			terminationFuture,
			getVersion(),
			configuration.getMaximumFramesize());
	} else {
		akkaRpcActorProps = Props.create(
			AkkaRpcActor.class,
			rpcEndpoint,
			terminationFuture,
			getVersion(),
			configuration.getMaximumFramesize());
	}

	ActorRef actorRef;

	synchronized (lock) {
		checkState(!stopped, "RpcService is stopped");
		actorRef = actorSystem.actorOf(akkaRpcActorProps, rpcEndpoint.getEndpointId());
		actors.put(actorRef, rpcEndpoint);
	}

	LOG.info("Starting RPC endpoint for {} at {} .", rpcEndpoint.getClass().getName(), actorRef.path());

	final String akkaAddress = AkkaUtils.getAkkaURL(actorSystem, actorRef);
	final String hostname;
	Option<String> host = actorRef.path().address().host();
	if (host.isEmpty()) {
		hostname = "localhost";
	} else {
		hostname = host.get();
	}

	Set<Class<?>> implementedRpcGateways = new HashSet<>(RpcUtils.extractImplementedRpcGateways(rpcEndpoint.getClass()));

	implementedRpcGateways.add(RpcServer.class);
	implementedRpcGateways.add(AkkaBasedEndpoint.class);

	final InvocationHandler akkaInvocationHandler;

	if (rpcEndpoint instanceof FencedRpcEndpoint) {
		// a FencedRpcEndpoint needs a FencedAkkaInvocationHandler
		akkaInvocationHandler = new FencedAkkaInvocationHandler<>(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			terminationFuture,
			((FencedRpcEndpoint<?>) rpcEndpoint)::getFencingToken);

		implementedRpcGateways.add(FencedMainThreadExecutable.class);
	} else {
		akkaInvocationHandler = new AkkaInvocationHandler(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			terminationFuture);
	}

	// Rather than using the System ClassLoader directly, we derive the ClassLoader
	// from this class . That works better in cases where Flink runs embedded and all Flink
	// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
	ClassLoader classLoader = getClass().getClassLoader();

	@SuppressWarnings("unchecked")
	RpcServer server = (RpcServer) Proxy.newProxyInstance(
		classLoader,
		implementedRpcGateways.toArray(new Class<?>[implementedRpcGateways.size()]),
		akkaInvocationHandler);

	return server;
}
 

@Override
public <C extends RpcEndpoint & RpcGateway> RpcServer startServer(C rpcEndpoint) {
	checkNotNull(rpcEndpoint, "rpc endpoint");

	CompletableFuture<Void> terminationFuture = new CompletableFuture<>();
	final Props akkaRpcActorProps;

	if (rpcEndpoint instanceof FencedRpcEndpoint) {
		akkaRpcActorProps = Props.create(
			FencedAkkaRpcActor.class,
			rpcEndpoint,
			terminationFuture,
			getVersion(),
			configuration.getMaximumFramesize());
	} else {
		akkaRpcActorProps = Props.create(
			AkkaRpcActor.class,
			rpcEndpoint,
			terminationFuture,
			getVersion(),
			configuration.getMaximumFramesize());
	}

	ActorRef actorRef;

	synchronized (lock) {
		checkState(!stopped, "RpcService is stopped");
		actorRef = actorSystem.actorOf(akkaRpcActorProps, rpcEndpoint.getEndpointId());
		actors.put(actorRef, rpcEndpoint);
	}

	LOG.info("Starting RPC endpoint for {} at {} .", rpcEndpoint.getClass().getName(), actorRef.path());

	final String akkaAddress = AkkaUtils.getAkkaURL(actorSystem, actorRef);
	final String hostname;
	Option<String> host = actorRef.path().address().host();
	if (host.isEmpty()) {
		hostname = "localhost";
	} else {
		hostname = host.get();
	}

	Set<Class<?>> implementedRpcGateways = new HashSet<>(RpcUtils.extractImplementedRpcGateways(rpcEndpoint.getClass()));

	implementedRpcGateways.add(RpcServer.class);
	implementedRpcGateways.add(AkkaBasedEndpoint.class);

	final InvocationHandler akkaInvocationHandler;

	if (rpcEndpoint instanceof FencedRpcEndpoint) {
		// a FencedRpcEndpoint needs a FencedAkkaInvocationHandler
		akkaInvocationHandler = new FencedAkkaInvocationHandler<>(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			terminationFuture,
			((FencedRpcEndpoint<?>) rpcEndpoint)::getFencingToken);

		implementedRpcGateways.add(FencedMainThreadExecutable.class);
	} else {
		akkaInvocationHandler = new AkkaInvocationHandler(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			terminationFuture);
	}

	// Rather than using the System ClassLoader directly, we derive the ClassLoader
	// from this class . That works better in cases where Flink runs embedded and all Flink
	// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
	ClassLoader classLoader = getClass().getClassLoader();

	@SuppressWarnings("unchecked")
	RpcServer server = (RpcServer) Proxy.newProxyInstance(
		classLoader,
		implementedRpcGateways.toArray(new Class<?>[implementedRpcGateways.size()]),
		akkaInvocationHandler);

	return server;
}
 

@Override
public <C extends RpcEndpoint & RpcGateway> RpcServer startServer(C rpcEndpoint) {
	checkNotNull(rpcEndpoint, "rpc endpoint");

	final SupervisorActor.ActorRegistration actorRegistration = registerAkkaRpcActor(rpcEndpoint);
	final ActorRef actorRef = actorRegistration.getActorRef();
	final CompletableFuture<Void> actorTerminationFuture = actorRegistration.getTerminationFuture();

	LOG.info("Starting RPC endpoint for {} at {} .", rpcEndpoint.getClass().getName(), actorRef.path());

	final String akkaAddress = AkkaUtils.getAkkaURL(actorSystem, actorRef);
	final String hostname;
	Option<String> host = actorRef.path().address().host();
	if (host.isEmpty()) {
		hostname = "localhost";
	} else {
		hostname = host.get();
	}

	Set<Class<?>> implementedRpcGateways = new HashSet<>(RpcUtils.extractImplementedRpcGateways(rpcEndpoint.getClass()));

	implementedRpcGateways.add(RpcServer.class);
	implementedRpcGateways.add(AkkaBasedEndpoint.class);

	final InvocationHandler akkaInvocationHandler;

	if (rpcEndpoint instanceof FencedRpcEndpoint) {
		// a FencedRpcEndpoint needs a FencedAkkaInvocationHandler
		akkaInvocationHandler = new FencedAkkaInvocationHandler<>(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			actorTerminationFuture,
			((FencedRpcEndpoint<?>) rpcEndpoint)::getFencingToken,
			captureAskCallstacks);

		implementedRpcGateways.add(FencedMainThreadExecutable.class);
	} else {
		akkaInvocationHandler = new AkkaInvocationHandler(
			akkaAddress,
			hostname,
			actorRef,
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			actorTerminationFuture,
			captureAskCallstacks);
	}

	// Rather than using the System ClassLoader directly, we derive the ClassLoader
	// from this class . That works better in cases where Flink runs embedded and all Flink
	// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
	ClassLoader classLoader = getClass().getClassLoader();

	@SuppressWarnings("unchecked")
	RpcServer server = (RpcServer) Proxy.newProxyInstance(
		classLoader,
		implementedRpcGateways.toArray(new Class<?>[implementedRpcGateways.size()]),
		akkaInvocationHandler);

	return server;
}