def test_sarama_http_server(self):
sarama_example = SaramaExamples.SaramaHttpServer(self.redpanda)
example = ExampleRunner(self._ctx,
sarama_example,
timeout_sec=self._timeout)
# Start the example
example.start()
# Wait for the server to load
example.wait()
# Get the node the server is on and
# a ducktape node
server_name = example.node_name()
node = random.choice(self.redpanda.nodes)
# Http get request using curl
curl = f"curl -SL http://{server_name}:8080/"
def try_curl():
result = node.account.ssh_output(curl, timeout_sec=5).decode()
self.logger.debug(result)
return "Your data is stored with unique identifier" in result
# Using wait_until for auto-retry because sometimes
# redpanda is in the middle of a leadership election when
# we try to http get.
wait_until(try_curl,
timeout_sec=self._timeout,
backoff_sec=5,
err_msg="sarama http_server test failed")
def test_sarama_consumergroup(self):
count = 10 if self.scale.local else 5000
sarama_example = SaramaExamples.SaramaConsumerGroup(
self.redpanda, self.topic, count)
example = ExampleRunner(self._ctx,
sarama_example,
timeout_sec=self._timeout)
producer = KafProducer(self._ctx, self.redpanda, self.topic, count)
def until_partitions():
storage = self.redpanda.storage()
return len(list(storage.partitions("kafka", self.topic))) == 3
# Must wait for the paritions to materialize or else
# kaf may try to produce during leadership election.
# This results in a skipped record since kaf doesn't auto-retry.
wait_until(until_partitions,
timeout_sec=30,
backoff_sec=2,
err_msg="Expected partition did not materialize")
# Run the producer and wait for the worker
# threads to finish producing
producer.start()
producer.wait()
# Start the example
example.start()
# Wait until the example is OK to terminate
example.wait()
def test_sarama_interceptors(self):
sarama_example = SaramaExamples.SaramaInterceptors(
self.redpanda, self.topic)
example = ExampleRunner(self._ctx,
sarama_example,
timeout_sec=self._timeout)
# Start the example
example.start()
example.wait()
class FranzGoBase(RedpandaTest):
"""
Test FranzGo bench example.
Not using any other example because bench tests the same
APIs and code that the other examples do.
"""
topics = (TopicSpec(), )
def __init__(self, test_context, enable_sasl=False, group=None):
# idempotence is necessary for bench example
extra_rp_conf = {
"enable_idempotence": True,
"enable_sasl": enable_sasl
}
self._ctx = test_context
super(FranzGoBase, self).__init__(test_context=test_context,
extra_rp_conf=extra_rp_conf)
self._max_records = 1000 if self.scale.local else 1000000
self._enable_sasl = enable_sasl
# In CI, it takes approx 300s to produce/consume 1mill records (or 3333.33 records/s).
# The closest factor of 1mill is 320s (or 3125 records/s).
# Also, add 30 seconds because sometimes franzgo doesn't produce/consume
# immediatly since RP is in middle of election or other
# background tasks.
self._timeout = math.ceil(self._max_records / 3125) + 30
self.logger.debug(self._timeout)
franzgo_producer = FranzGoExamples.FranzGoBenchProduce(
self.redpanda, self.topic, self._max_records, self._enable_sasl)
self._producer = ExampleRunner(self._ctx,
franzgo_producer,
timeout_sec=self._timeout)
franzgo_consumer = FranzGoExamples.FranzGoBenchConsume(
self.redpanda, self.topic, self._max_records, self._enable_sasl,
group)
self._consumer = ExampleRunner(self._ctx,
franzgo_consumer,
timeout_sec=self._timeout)
@cluster(num_nodes=5)
def test_franzgo_bench(self):
# Start the produce bench
self._producer.start()
self._producer.wait()
# Start the consume bench.
# Running the example sequentially because
# it's easier to debug.
self._consumer.start()
self._consumer.wait()
def test_kafka_streams(self):
example = self.create_example()
# This will raise TypeError if DriverHeler is undefined
driver_helper = self.Driver(self.redpanda, True)
driver = ExampleRunner(self._ctx,
driver_helper,
timeout_sec=self._timeout)
# Start the example
example.start()
example.wait()
# Start the driver
driver.start()
driver.wait()
driver.stop()
example.stop()