def test_version_probing_upgrade(self):
"""
Starts 3 KafkaStreams instances, and upgrades one-by-one to "future version"
"""
self.zk = ZookeeperService(self.test_context, num_nodes=1)
self.zk.start()
self.kafka = KafkaService(self.test_context,
num_nodes=1,
zk=self.zk,
topics=self.topics)
self.kafka.start()
self.driver = StreamsSmokeTestDriverService(self.test_context,
self.kafka)
self.driver.disable_auto_terminate()
self.processor1 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.processor2 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.processor3 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.driver.start()
self.start_all_nodes_with("") # run with TRUNK
self.processors = [self.processor1, self.processor2, self.processor3]
self.old_processors = [
self.processor1, self.processor2, self.processor3
]
self.upgraded_processors = []
for p in self.processors:
self.leader_counter[p] = 2
self.update_leader()
for p in self.processors:
self.leader_counter[p] = 0
self.leader_counter[self.leader] = 3
counter = 1
current_generation = 3
random.seed()
random.shuffle(self.processors)
for p in self.processors:
p.CLEAN_NODE_ENABLED = False
current_generation = self.do_rolling_bounce(
p, counter, current_generation)
counter = counter + 1
# shutdown
self.driver.stop()
self.driver.wait()
random.shuffle(self.processors)
for p in self.processors:
node = p.node
with node.account.monitor_log(p.STDOUT_FILE) as monitor:
p.stop()
monitor.wait_until(
"UPGRADE-TEST-CLIENT-CLOSED",
timeout_sec=60,
err_msg="Never saw output 'UPGRADE-TEST-CLIENT-CLOSED' on"
+ str(node.account))
self.driver.stop()
def test_metadata_upgrade(self, from_version, to_version):
"""
Starts 3 KafkaStreams instances with version <from_version> and upgrades one-by-one to <to_version>
"""
self.zk = ZookeeperService(self.test_context, num_nodes=1)
self.zk.start()
self.kafka = KafkaService(self.test_context,
num_nodes=1,
zk=self.zk,
topics=self.topics)
self.kafka.start()
self.driver = StreamsSmokeTestDriverService(self.test_context,
self.kafka)
self.driver.disable_auto_terminate()
self.processor1 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.processor2 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.processor3 = StreamsUpgradeTestJobRunnerService(
self.test_context, self.kafka)
self.driver.start()
self.start_all_nodes_with(from_version)
self.processors = [self.processor1, self.processor2, self.processor3]
counter = 1
random.seed()
# first rolling bounce
random.shuffle(self.processors)
for p in self.processors:
p.CLEAN_NODE_ENABLED = False
self.do_stop_start_bounce(p, from_version[:-2], to_version,
counter)
counter = counter + 1
# second rolling bounce
random.shuffle(self.processors)
for p in self.processors:
self.do_stop_start_bounce(p, None, to_version, counter)
counter = counter + 1
# shutdown
self.driver.stop()
self.driver.wait()
random.shuffle(self.processors)
for p in self.processors:
node = p.node
with node.account.monitor_log(p.STDOUT_FILE) as monitor:
p.stop()
monitor.wait_until(
"UPGRADE-TEST-CLIENT-CLOSED",
timeout_sec=60,
err_msg="Never saw output 'UPGRADE-TEST-CLIENT-CLOSED' on"
+ str(node.account))
self.driver.stop()
def test_upgrade_downgrade_brokers(self, from_version, to_version):
"""
Start a smoke test client then perform rolling upgrades on the broker.
"""
if from_version == to_version:
return
self.replication = 3
self.num_kafka_nodes = 3
self.partitions = 1
self.isr = 2
self.topics = {
'echo': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'data': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'min': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'max': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'sum': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'dif': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'cnt': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'avg': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'wcnt': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'tagg': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
}
}
# Setup phase
self.zk = ZookeeperService(self.test_context, num_nodes=1)
self.zk.start()
# number of nodes needs to be >= 3 for the smoke test
self.kafka = KafkaService(self.test_context,
num_nodes=self.num_kafka_nodes,
zk=self.zk,
version=KafkaVersion(from_version),
topics=self.topics)
self.kafka.start()
# allow some time for topics to be created
wait_until(lambda: self.confirm_topics_on_all_brokers(
set(self.topics.keys())),
timeout_sec=60,
err_msg="Broker did not create all topics in 60 seconds ")
self.driver = StreamsSmokeTestDriverService(self.test_context,
self.kafka)
processor = StreamsSmokeTestJobRunnerService(self.test_context,
self.kafka,
"at_least_once")
with self.driver.node.account.monitor_log(
self.driver.STDOUT_FILE) as driver_monitor:
self.driver.start()
with processor.node.account.monitor_log(
processor.STDOUT_FILE) as monitor:
processor.start()
monitor.wait_until(
self.processed_msg,
timeout_sec=60,
err_msg="Never saw output '%s' on " % self.processed_msg +
str(processor.node))
connected_message = "Discovered group coordinator"
with processor.node.account.monitor_log(
processor.LOG_FILE) as log_monitor:
with processor.node.account.monitor_log(
processor.STDOUT_FILE) as stdout_monitor:
self.perform_broker_upgrade(to_version)
log_monitor.wait_until(
connected_message,
timeout_sec=120,
err_msg=("Never saw output '%s' on " %
connected_message) +
str(processor.node.account))
stdout_monitor.wait_until(
self.processed_msg,
timeout_sec=60,
err_msg="Never saw output '%s' on" % self.processed_msg
+ str(processor.node.account))
# SmokeTestDriver allows up to 6 minutes to consume all
# records for the verification step so this timeout is set to
# 6 minutes (360 seconds) for consuming of verification records
# and a very conservative additional 2 minutes (120 seconds) to process
# the records in the verification step
driver_monitor.wait_until(
'ALL-RECORDS-DELIVERED\|PROCESSED-MORE-THAN-GENERATED',
timeout_sec=480,
err_msg="Never saw output '%s' on" %
'ALL-RECORDS-DELIVERED|PROCESSED-MORE-THAN-GENERATED' +
str(self.driver.node.account))
self.driver.stop()
processor.stop()
processor.node.account.ssh_capture("grep SMOKE-TEST-CLIENT-CLOSED %s" %
processor.STDOUT_FILE,
allow_fail=False)
def __init__(self, test_context):
super(StreamsMultipleRollingUpgradeTest,
self).__init__(test_context,
topics={
'echo': {
'partitions': 5,
'replication-factor': 1
},
'data': {
'partitions': 5,
'replication-factor': 1
},
'min': {
'partitions': 5,
'replication-factor': 1
},
'max': {
'partitions': 5,
'replication-factor': 1
},
'sum': {
'partitions': 5,
'replication-factor': 1
},
'dif': {
'partitions': 5,
'replication-factor': 1
},
'cnt': {
'partitions': 5,
'replication-factor': 1
},
'avg': {
'partitions': 5,
'replication-factor': 1
},
'wcnt': {
'partitions': 5,
'replication-factor': 1
},
'tagg': {
'partitions': 5,
'replication-factor': 1
}
})
self.driver = StreamsSmokeTestDriverService(test_context, self.kafka)
self.processor_1 = StreamsSmokeTestJobRunnerService(
test_context, self.kafka)
self.processor_2 = StreamsSmokeTestJobRunnerService(
test_context, self.kafka)
self.processor_3 = StreamsSmokeTestJobRunnerService(
test_context, self.kafka)
# already on trunk version at end of upgrades so get rid of it
self.streams_downgrade_versions = self.streams_upgrade_versions[:-1]
self.streams_downgrade_versions.reverse()
self.processors = [
self.processor_1, self.processor_2, self.processor_3
]
self.started = False
def __init__(self, test_context):
super(StreamsSmokeTest, self).__init__(test_context,
num_zk=1,
num_brokers=3,
topics={
'echo': {
'partitions': 5,
'replication-factor': 1
},
'data': {
'partitions': 5,
'replication-factor': 1
},
'min': {
'partitions': 5,
'replication-factor': 1
},
'min-suppressed': {
'partitions': 5,
'replication-factor': 1
},
'min-raw': {
'partitions': 5,
'replication-factor': 1
},
'max': {
'partitions': 5,
'replication-factor': 1
},
'sum': {
'partitions': 5,
'replication-factor': 1
},
'sws-raw': {
'partitions': 5,
'replication-factor': 1
},
'sws-suppressed': {
'partitions': 5,
'replication-factor': 1
},
'dif': {
'partitions': 5,
'replication-factor': 1
},
'cnt': {
'partitions': 5,
'replication-factor': 1
},
'avg': {
'partitions': 5,
'replication-factor': 1
},
'wcnt': {
'partitions': 5,
'replication-factor': 1
},
'tagg': {
'partitions': 5,
'replication-factor': 1
}
})
self.test_context = test_context
self.driver = StreamsSmokeTestDriverService(test_context, self.kafka)
def test_upgrade_downgrade_brokers(self, from_version, to_version):
"""
Start a smoke test client then perform rolling upgrades on the broker.
"""
if from_version == to_version:
return
self.replication = 3
self.partitions = 1
self.isr = 2
self.topics = {
'echo': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'data': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'min': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'max': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'sum': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'dif': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'cnt': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'avg': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'wcnt': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
},
'tagg': {
'partitions': self.partitions,
'replication-factor': self.replication,
'configs': {
"min.insync.replicas": self.isr
}
}
}
# Setup phase
self.zk = ZookeeperService(self.test_context, num_nodes=1)
self.zk.start()
# number of nodes needs to be >= 3 for the smoke test
self.kafka = KafkaService(self.test_context,
num_nodes=3,
zk=self.zk,
version=KafkaVersion(from_version),
topics=self.topics)
self.kafka.start()
# allow some time for topics to be created
time.sleep(10)
self.driver = StreamsSmokeTestDriverService(self.test_context,
self.kafka)
self.processor1 = StreamsSmokeTestJobRunnerService(
self.test_context, self.kafka)
self.driver.start()
self.processor1.start()
time.sleep(15)
self.perform_broker_upgrade(to_version)
time.sleep(15)
self.driver.wait()
self.driver.stop()
self.processor1.stop()
node = self.driver.node
node.account.ssh("grep ALL-RECORDS-DELIVERED %s" %
self.driver.STDOUT_FILE,
allow_fail=False)
self.processor1.node.account.ssh_capture(
"grep SMOKE-TEST-CLIENT-CLOSED %s" % self.processor1.STDOUT_FILE,
allow_fail=False)
