Java Callback.onCompletion方法代码示例

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@Test
public void testCallbackWillNotTriggerOnFailedDeliveryOnNoException() {
    final ProducerRecord<String,String> record = new ProducerRecord<String,String>("topic", 0, null, "msg");
    unit.send(producer, record, "msg", failedDeliveryCallback);

    final ArgumentCaptor<Callback> callbackCaptor = ArgumentCaptor.forClass(Callback.class);
    verify(producer).send(Mockito.refEq(record), callbackCaptor.capture());

    final Callback callback = callbackCaptor.getValue();
    callback.onCompletion(recordMetadata, null);

    verify(failedDeliveryCallback, never()).onFailedDelivery(anyString(), any(Throwable.class));
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@Test
public void testCallbackWillTriggerOnFailedDeliveryOnException() {
    final IOException exception = new IOException("KABOOM");
    final ProducerRecord<String,String> record = new ProducerRecord<String,String>("topic", 0, null, "msg");
    unit.send(producer, record, "msg", failedDeliveryCallback);

    final ArgumentCaptor<Callback> callbackCaptor = ArgumentCaptor.forClass(Callback.class);
    verify(producer).send(Mockito.refEq(record), callbackCaptor.capture());

    final Callback callback = callbackCaptor.getValue();
    callback.onCompletion(recordMetadata, exception);

    verify(failedDeliveryCallback).onFailedDelivery("msg", exception);
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test(expected = StreamsException.class)
public void shouldThrowStreamsExceptionOnSubsequentCallIfASendFails() throws Exception {
    final RecordCollector collector = new RecordCollectorImpl(
            new MockProducer(cluster, true, new DefaultPartitioner(), byteArraySerializer, byteArraySerializer) {
                @Override
                public synchronized Future<RecordMetadata> send(final ProducerRecord record, final Callback callback) {
                    callback.onCompletion(null, new Exception());
                    return null;
                }
            },
            "test");
    collector.send("topic1", "3", "0", null, stringSerializer, stringSerializer, streamPartitioner);
    collector.send("topic1", "3", "0", null, stringSerializer, stringSerializer, streamPartitioner);
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test(expected = StreamsException.class)
public void shouldThrowStreamsExceptionOnFlushIfASendFailed() throws Exception {
    final RecordCollector collector = new RecordCollectorImpl(
            new MockProducer(cluster, true, new DefaultPartitioner(), byteArraySerializer, byteArraySerializer) {
                @Override
                public synchronized Future<RecordMetadata> send(final ProducerRecord record, final Callback callback) {
                    callback.onCompletion(null, new Exception());
                    return null;
                }
            },
            "test");
    collector.send("topic1", "3", "0", null, stringSerializer, stringSerializer, streamPartitioner);
    collector.flush();
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Test(expected = StreamsException.class)
public void shouldThrowStreamsExceptionOnCloseIfASendFailed() throws Exception {
    final RecordCollector collector = new RecordCollectorImpl(
            new MockProducer(cluster, true, new DefaultPartitioner(), byteArraySerializer, byteArraySerializer) {
                @Override
                public synchronized Future<RecordMetadata> send(final ProducerRecord record, final Callback callback) {
                    callback.onCompletion(null, new Exception());
                    return null;
                }
            },
            "test");
    collector.send("topic1", "3", "0", null, stringSerializer, stringSerializer, streamPartitioner);
    collector.close();
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@Override
public Future<RecordMetadata> send(ProducerRecord<K, V> record, final Callback callback) {
  boolean error = errorManager.nextError(record.value());
  if (errorManager.nextError(record.value()))
  {
    final Exception e = new Exception();
    callback.onCompletion(null, e);
    return nullFuture;
  }
  else {
    return super.send(record, callback);
  }

}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
@Override
public synchronized Future<RecordMetadata> send(ProducerRecord<String, String> record, Callback callback) {
  callback.onCompletion(null, new SimulatedWriteException());
  return super.send(record, callback);
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
private void runTest(boolean flushOnCheckpoint) throws Throwable {
	Properties props = new Properties();
	final AtomicBoolean snapshottingFinished = new AtomicBoolean(false);

	final TestingKafkaProducer<String> producer = new TestingKafkaProducer<>("someTopic", new KeyedSerializationSchemaWrapper<>(new SimpleStringSchema()), props,
			snapshottingFinished);

	producer.setFlushOnCheckpoint(flushOnCheckpoint);

	OneInputStreamOperatorTestHarness<String, Object> testHarness =
			new OneInputStreamOperatorTestHarness<>(new StreamSink(producer));

	testHarness.open();

	for (int i = 0; i < 100; i++) {
		testHarness.processElement(new StreamRecord<>("msg-" + i));
	}

	// start a thread confirming all pending records
	final Tuple1<Throwable> runnableError = new Tuple1<>(null);
	final Thread threadA = Thread.currentThread();

	Runnable confirmer = new Runnable() {
		@Override
		public void run() {
			try {
				MockProducer mp = producer.getProducerInstance();
				List<Callback> pending = mp.getPending();

				// we need to find out if the snapshot() method blocks forever
				// this is not possible. If snapshot() is running, it will
				// start removing elements from the pending list.
				synchronized (threadA) {
					threadA.wait(500L);
				}
				// we now check that no records have been confirmed yet
				Assert.assertEquals(100, pending.size());
				Assert.assertFalse("Snapshot method returned before all records were confirmed",
						snapshottingFinished.get());

				// now confirm all checkpoints
				for (Callback c: pending) {
					c.onCompletion(null, null);
				}
				pending.clear();
			} catch(Throwable t) {
				runnableError.f0 = t;
			}
		}
	};
	Thread threadB = new Thread(confirmer);
	threadB.start();

	// this should block:
	testHarness.snapshot(0, 0);

	synchronized (threadA) {
		threadA.notifyAll(); // just in case, to let the test fail faster
	}
	Assert.assertEquals(0, producer.getProducerInstance().getPending().size());
	Deadline deadline = FiniteDuration.apply(5, "s").fromNow();
	while (deadline.hasTimeLeft() && threadB.isAlive()) {
		threadB.join(500);
	}
	Assert.assertFalse("Thread A is expected to be finished at this point. If not, the test is prone to fail", threadB.isAlive());
	if (runnableError.f0 != null) {
		throw runnableError.f0;
	}

	testHarness.close();
}
 

import org.apache.kafka.clients.producer.Callback; //导入方法依赖的package包/类
private void runAtLeastOnceTest(boolean flushOnCheckpoint) throws Throwable {
	final AtomicBoolean snapshottingFinished = new AtomicBoolean(false);
	final DummyFlinkKafkaProducer<String> producer = new DummyFlinkKafkaProducer<>(
		FakeStandardProducerConfig.get(), null, snapshottingFinished);
	producer.setFlushOnCheckpoint(flushOnCheckpoint);

	OneInputStreamOperatorTestHarness<String, Object> testHarness =
			new OneInputStreamOperatorTestHarness<>(new StreamSink(producer));

	testHarness.open();

	for (int i = 0; i < 100; i++) {
		testHarness.processElement(new StreamRecord<>("msg-" + i));
	}

	// start a thread confirming all pending records
	final Tuple1<Throwable> runnableError = new Tuple1<>(null);
	final Thread threadA = Thread.currentThread();

	Runnable confirmer = new Runnable() {
		@Override
		public void run() {
			try {
				MockProducer mp = producer.getProducerInstance();
				List<Callback> pending = mp.getPending();

				// we need to find out if the snapshot() method blocks forever
				// this is not possible. If snapshot() is running, it will
				// start removing elements from the pending list.
				synchronized (threadA) {
					threadA.wait(500L);
				}
				// we now check that no records have been confirmed yet
				Assert.assertEquals(100, pending.size());
				Assert.assertFalse("Snapshot method returned before all records were confirmed",
					snapshottingFinished.get());

				// now confirm all checkpoints
				for (Callback c: pending) {
					c.onCompletion(null, null);
				}
				pending.clear();
			} catch(Throwable t) {
				runnableError.f0 = t;
			}
		}
	};
	Thread threadB = new Thread(confirmer);
	threadB.start();

	// this should block:
	testHarness.snapshot(0, 0);

	synchronized (threadA) {
		threadA.notifyAll(); // just in case, to let the test fail faster
	}
	Assert.assertEquals(0, producer.getProducerInstance().getPending().size());
	Deadline deadline = FiniteDuration.apply(5, "s").fromNow();
	while (deadline.hasTimeLeft() && threadB.isAlive()) {
		threadB.join(500);
	}
	Assert.assertFalse("Thread A is expected to be finished at this point. If not, the test is prone to fail", threadB.isAlive());
	if (runnableError.f0 != null) {
		throw runnableError.f0;
	}

	testHarness.close();
}