org.apache.flink.util.function.BiConsumerWithException Java Examples

static ChannelStateWriteRequest buildWriteRequest(
		long checkpointId,
		String name,
		CloseableIterator<Buffer> iterator,
		BiConsumerWithException<ChannelStateCheckpointWriter, Buffer, Exception> bufferConsumer) {
	return new CheckpointInProgressRequest(
		name,
		checkpointId,
		writer -> {
			while (iterator.hasNext()) {
				Buffer buffer = iterator.next();
				try {
					checkArgument(buffer.isBuffer());
				} catch (Exception e) {
					buffer.recycleBuffer();
					throw e;
				}
				bufferConsumer.accept(writer, buffer);
			}
		},
		throwable -> iterator.close(),
		false);
}
 

TestingExecutor(
		List<SupplierWithException<TypedResult<List<Tuple2<Boolean, Row>>>, SqlExecutionException>> resultChanges,
		List<SupplierWithException<TypedResult<Integer>, SqlExecutionException>> snapshotResults,
		List<SupplierWithException<List<Row>, SqlExecutionException>> resultPages,
		BiConsumerWithException<String, String, SqlExecutionException> useCatalogConsumer,
		BiConsumerWithException<String, String, SqlExecutionException> useDatabaseConsumer,
		BiFunctionWithException<String, String, TableResult, SqlExecutionException> executeSqlConsumer,
		TriFunctionWithException<String, String, String, Void, SqlExecutionException> setSessionPropertyFunction,
		FunctionWithException<String, Void, SqlExecutionException> resetSessionPropertiesFunction) {
	this.resultChanges = resultChanges;
	this.snapshotResults = snapshotResults;
	this.resultPages = resultPages;
	this.useCatalogConsumer = useCatalogConsumer;
	this.useDatabaseConsumer = useDatabaseConsumer;
	this.executeSqlConsumer = executeSqlConsumer;
	this.setSessionPropertyFunction = setSessionPropertyFunction;
	this.resetSessionPropertiesFunction = resetSessionPropertiesFunction;
	helper = new SqlParserHelper();
	helper.registerTables();
}
 

public static <K, V> void writeOptionalMap(
	DataOutputView out,
	LinkedOptionalMap<K, V> map,
	BiConsumerWithException<DataOutputView, K, IOException> keyWriter,
	BiConsumerWithException<DataOutputView, V, IOException> valueWriter) throws IOException {

	out.writeLong(HEADER);
	out.writeInt(map.size());
	map.forEach(((keyName, key, value) -> {
		out.writeUTF(keyName);

		if (key == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, keyWriter, key);
		}

		if (value == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, valueWriter, value);
		}
	}));
}
 

@Override
public void forEachProcessingTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	for (Timer<K, N> timer : processingTimeTimers) {
		keyContext.setCurrentKey(timer.getKey());
		consumer.accept(timer.getNamespace(), timer.getTimestamp());
	}
}
 

@Override
public void forEachEventTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	for (Timer<K, N> timer : watermarkTimers) {
		keyContext.setCurrentKey(timer.getKey());
		consumer.accept(timer.getNamespace(), timer.getTimestamp());
	}
}
 

private void foreachTimer(BiConsumerWithException<N, Long, Exception> consumer, KeyGroupedInternalPriorityQueue<TimerHeapInternalTimer<K, N>> queue) throws Exception {
	try (final CloseableIterator<TimerHeapInternalTimer<K, N>> iterator = queue.iterator()) {
		while (iterator.hasNext()) {
			final TimerHeapInternalTimer<K, N> timer = iterator.next();
			keyContext.setCurrentKey(timer.getKey());
			consumer.accept(timer.getNamespace(), timer.getTimestamp());
		}
	}
}
 

TestingJobLeaderService(
		QuadConsumer<String, RpcService, HighAvailabilityServices, JobLeaderListener> startConsumer,
		ThrowingRunnable<? extends Exception> stopRunnable,
		Consumer<JobID> removeJobConsumer,
		BiConsumerWithException<JobID, String, ? extends Exception> addJobConsumer,
		Consumer<JobID> reconnectConsumer,
		Function<JobID, Boolean> containsJobFunction) {
	this.startConsumer = startConsumer;
	this.stopRunnable = stopRunnable;
	this.removeJobConsumer = removeJobConsumer;
	this.addJobConsumer = addJobConsumer;
	this.reconnectConsumer = reconnectConsumer;
	this.containsJobFunction = containsJobFunction;
}
 

private void runWithSyncWorker(BiConsumerWithException<ChannelStateWriter, SyncChannelStateWriteRequestExecutor, Exception> testFn) throws Exception {
	try (
			SyncChannelStateWriteRequestExecutor worker = new SyncChannelStateWriteRequestExecutor();
			ChannelStateWriterImpl writer = new ChannelStateWriterImpl(TASK_NAME, new ConcurrentHashMap<>(), worker, 5)
	) {
		writer.open();
		testFn.accept(writer, worker);
		worker.processAllRequests();
	}
}
 

private void testSubmitFailure(BiConsumerWithException<ChannelStateWriteRequestExecutor, ChannelStateWriteRequest, Exception> submitAction) throws Exception {
	TestWriteRequest request = new TestWriteRequest();
	LinkedBlockingDeque<ChannelStateWriteRequest> deque = new LinkedBlockingDeque<>();
	try {
		submitAction.accept(new ChannelStateWriteRequestExecutorImpl(TASK_NAME, NO_OP, deque), request);
	} catch (IllegalStateException e) {
		// expected: executor not started;
		return;
	} finally {
		assertTrue(request.cancelled);
		assertTrue(deque.isEmpty());
	}
	throw new RuntimeException("expected exception not thrown");
}
 

private void testCloseAfterSubmit(BiConsumerWithException<ChannelStateWriteRequestExecutor, ChannelStateWriteRequest, Exception> requestFun) throws Exception {
	WorkerClosingDeque closingDeque = new WorkerClosingDeque();
	ChannelStateWriteRequestExecutorImpl worker = new ChannelStateWriteRequestExecutorImpl(TASK_NAME, NO_OP, closingDeque);
	closingDeque.setWorker(worker);
	TestWriteRequest request = new TestWriteRequest();
	requestFun.accept(worker, request);
	assertTrue(closingDeque.isEmpty());
	assertFalse(request.isCancelled());
}
 

private CompletableFuture<Void> persistAndRunJob(JobGraph jobGraph) throws Exception {
	jobGraphWriter.putJobGraph(jobGraph);

	final CompletableFuture<Void> runJobFuture = runJob(jobGraph);

	return runJobFuture.whenComplete(BiConsumerWithException.unchecked((Object ignored, Throwable throwable) -> {
		if (throwable != null) {
			jobGraphWriter.removeJobGraph(jobGraph.getJobID());
		}
	}));
}
 

private <T extends StateObject> void serializeCollection(
	StateObjectCollection<T> stateObjectCollection,
	DataOutputStream dos,
	BiConsumerWithException<T, DataOutputStream, IOException> cons) throws IOException {
	if (stateObjectCollection == null) {
		dos.writeInt(0);
	} else {
		dos.writeInt(stateObjectCollection.size());
		for (T stateObject : stateObjectCollection) {
			cons.accept(stateObject, dos);
		}
	}
}
 

private static <T extends StateObject> void serializeSingleton(
		StateObjectCollection<T> stateObjectCollection,
		DataOutputStream dos,
		BiConsumerWithException<T, DataOutputStream, IOException> cons) throws IOException {
	final T state = extractSingleton(stateObjectCollection);
	if (state != null) {
		dos.writeInt(1);
		cons.accept(state, dos);
	} else {
		dos.writeInt(0);
	}
}
 

private static <I> void serializeChannelStateHandle(
		AbstractChannelStateHandle<I> handle,
		DataOutputStream dos,
		BiConsumerWithException<I, DataOutputStream, IOException> infoWriter) throws IOException {
	infoWriter.accept(handle.getInfo(), dos);
	dos.writeInt(handle.getOffsets().size());
	for (long offset : handle.getOffsets()) {
		dos.writeLong(offset);
	}
	dos.writeLong(handle.getStateSize());
	serializeStreamStateHandle(handle.getDelegate(), dos);
}
 

private static <T> void writeFramed(DataOutputView out, BiConsumerWithException<DataOutputView, T, IOException> writer, T item) throws IOException {
	DataOutputSerializer frame = new DataOutputSerializer(64);
	writer.accept(frame, item);

	final byte[] buffer = frame.getSharedBuffer();
	final int bufferSize = frame.length();
	out.writeInt(bufferSize);
	out.write(buffer, 0, bufferSize);
}
 

public static <K, V> void writeOptionalMap(
	DataOutputView out,
	LinkedOptionalMap<K, V> map,
	BiConsumerWithException<DataOutputView, K, IOException> keyWriter,
	BiConsumerWithException<DataOutputView, V, IOException> valueWriter) throws IOException {

	out.writeLong(HEADER);
	out.writeInt(map.size());
	map.forEach(((keyName, key, value) -> {
		out.writeUTF(keyName);

		if (key == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, keyWriter, key);
		}

		if (value == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, valueWriter, value);
		}
	}));
}
 

private static <T> void writeFramed(DataOutputView out, BiConsumerWithException<DataOutputView, T, IOException> writer, T item) throws IOException {
	DataOutputSerializer frame = new DataOutputSerializer(64);
	writer.accept(frame, item);

	final byte[] buffer = frame.getSharedBuffer();
	final int bufferSize = frame.length();
	out.writeInt(bufferSize);
	out.write(buffer, 0, bufferSize);
}
 

private CompletableFuture<Void> persistAndRunJob(JobGraph jobGraph) throws Exception {
	submittedJobGraphStore.putJobGraph(new SubmittedJobGraph(jobGraph));

	final CompletableFuture<Void> runJobFuture = runJob(jobGraph);

	return runJobFuture.whenComplete(BiConsumerWithException.unchecked((Object ignored, Throwable throwable) -> {
		if (throwable != null) {
			submittedJobGraphStore.removeJobGraph(jobGraph.getJobID());
		}
	}));
}
 

@Override
public void forEachProcessingTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	for (Timer<K, N> timer : processingTimeTimers) {
		keyContext.setCurrentKey(timer.getKey());
		consumer.accept(timer.getNamespace(), timer.getTimestamp());
	}
}
 

@Override
public void forEachEventTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	for (Timer<K, N> timer : watermarkTimers) {
		keyContext.setCurrentKey(timer.getKey());
		consumer.accept(timer.getNamespace(), timer.getTimestamp());
	}
}
 

private void foreachTimer(BiConsumerWithException<N, Long, Exception> consumer, KeyGroupedInternalPriorityQueue<TimerHeapInternalTimer<K, N>> queue) throws Exception {
	try (final CloseableIterator<TimerHeapInternalTimer<K, N>> iterator = queue.iterator()) {
		while (iterator.hasNext()) {
			final TimerHeapInternalTimer<K, N> timer = iterator.next();
			keyContext.setCurrentKey(timer.getKey());
			consumer.accept(timer.getNamespace(), timer.getTimestamp());
		}
	}
}
 

public static <K, V> void writeOptionalMap(
	DataOutputView out,
	LinkedOptionalMap<K, V> map,
	BiConsumerWithException<DataOutputView, K, IOException> keyWriter,
	BiConsumerWithException<DataOutputView, V, IOException> valueWriter) throws IOException {

	out.writeLong(HEADER);
	out.writeInt(map.size());
	map.forEach(((keyName, key, value) -> {
		out.writeUTF(keyName);

		if (key == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, keyWriter, key);
		}

		if (value == null) {
			out.writeBoolean(false);
		}
		else {
			out.writeBoolean(true);
			writeFramed(out, valueWriter, value);
		}
	}));
}
 

private static <T> void writeFramed(DataOutputView out, BiConsumerWithException<DataOutputView, T, IOException> writer, T item) throws IOException {
	DataOutputSerializer frame = new DataOutputSerializer(64);
	writer.accept(frame, item);

	final byte[] buffer = frame.getSharedBuffer();
	final int bufferSize = frame.length();
	out.writeInt(bufferSize);
	out.write(buffer, 0, bufferSize);
}
 

private CompletableFuture<Void> persistAndRunJob(JobGraph jobGraph) throws Exception {
	submittedJobGraphStore.putJobGraph(new SubmittedJobGraph(jobGraph));

	final CompletableFuture<Void> runJobFuture = runJob(jobGraph);

	return runJobFuture.whenComplete(BiConsumerWithException.unchecked((Object ignored, Throwable throwable) -> {
		if (throwable != null) {
			submittedJobGraphStore.removeJobGraph(jobGraph.getJobID());
		}
	}));
}
 

@Override
public void forEachEventTimeTimer(
    BiConsumerWithException<VoidNamespace, Long, Exception> consumer) throws Exception {
  throw new UnsupportedOperationException();
}
 

@SuppressWarnings("unchecked")
static <K> BiConsumerWithException<DataOutputView, K, IOException> noopWriter() {
	return (BiConsumerWithException<DataOutputView, K, IOException>) INSTANCE;
}
 

@Override
public void forEachProcessingTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	foreachTimer(consumer, processingTimeTimersQueue);
}
 

@Override
public void forEachEventTimeTimer(BiConsumerWithException<N, Long, Exception> consumer) throws Exception {
	foreachTimer(consumer, eventTimeTimersQueue);
}
 

public Builder setAddJobConsumer(BiConsumerWithException<JobID, String, ? extends Exception> addJobConsumer) {
	this.addJobConsumer = addJobConsumer;
	return this;
}
 

@SuppressWarnings("unchecked")
static <K> BiConsumerWithException<DataOutputView, K, IOException> noopWriter() {
	return (BiConsumerWithException<DataOutputView, K, IOException>) INSTANCE;
}