def test_can_adjust_config_from_dynamic_to_static_port():
sdk_tasks.check_running(config.SERVICE_NAME, config.DEFAULT_BROKER_COUNT)
broker_ids = sdk_tasks.get_task_ids(config.SERVICE_NAME,
'{}-'.format(config.DEFAULT_POD_TYPE))
marathon_config = sdk_marathon.get_config(config.SERVICE_NAME)
marathon_config['env']['BROKER_PORT'] = '9092'
sdk_marathon.update_app(config.SERVICE_NAME, marathon_config)
sdk_tasks.check_tasks_updated(config.SERVICE_NAME,
'{}-'.format(config.DEFAULT_POD_TYPE),
broker_ids)
# all tasks are running
sdk_tasks.check_running(config.SERVICE_NAME, config.DEFAULT_BROKER_COUNT)
for broker_id in range(config.DEFAULT_BROKER_COUNT):
result = test_utils.service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9092
result = test_utils.service_cli('endpoints broker')
assert len(result['address']) == config.DEFAULT_BROKER_COUNT
assert len(result['dns']) == config.DEFAULT_BROKER_COUNT
for port in result['address']:
assert int(port.split(':')[-1]) == 9092
for port in result['dns']:
assert int(port.split(':')[-1]) == 9092
def test_config_cli():
configs = service_cli('config list')
assert len(configs) == 1
assert service_cli('config show {}'.format(configs[0]))
assert service_cli('config target')
assert service_cli('config target_id')
def test_plan_cli():
assert service_cli('plan list')
assert service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert service_cli('plan interrupt {} {}'.format(DEFAULT_PLAN_NAME,
DEFAULT_PHASE_NAME))
assert service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME,
DEFAULT_PHASE_NAME))
def test_port_static_to_static_port():
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = tasks.get_task_ids(SERVICE_NAME,
'{}-'.format(DEFAULT_POD_TYPE))
config = marathon.get_config(SERVICE_NAME)
utils.out('Old Config :{}'.format(config))
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9092
config['env']['BROKER_PORT'] = '9095'
marathon.update_app(SERVICE_NAME, config)
utils.out('New Config :{}'.format(config))
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE),
broker_ids)
# all tasks are running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9095
def test_no_change():
broker_ids = tasks.get_task_ids(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE))
plan1 = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
config = marathon.get_config(SERVICE_NAME)
marathon.update_app(SERVICE_NAME, config)
plan2 = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert plan1 == plan2
try:
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE), broker_ids, timeout_seconds=60)
assert False, "Should not restart tasks now"
except AssertionError as arg:
raise arg
except:
pass
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
assert plan2['status'] == 'COMPLETE'
assert plan2['phases'][0]['status'] == 'COMPLETE'
for step in range(DEFAULT_BROKER_COUNT):
assert plan2['phases'][0]['steps'][step]['status'] == 'COMPLETE'
def test_pods_replace():
broker_0_id = tasks.get_task_ids(SERVICE_NAME, '{}-0-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME))
service_cli('pods replace {}-0'.format(DEFAULT_POD_TYPE))
tasks.check_tasks_updated(SERVICE_NAME, '{}-0-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME), broker_0_id)
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
# wait till all brokers register
broker_count_check(DEFAULT_BROKER_COUNT)
def test_port_static_to_dynamic_port():
sdk_tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = sdk_tasks.get_task_ids(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE))
config = sdk_marathon.get_config(SERVICE_NAME)
config['env']['BROKER_PORT'] = '0'
sdk_marathon.update_app(SERVICE_NAME, config)
sdk_tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE), broker_ids)
# all tasks are running
sdk_tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] != 9092
result = service_cli('endpoints broker')
assert len(result['address']) == DEFAULT_BROKER_COUNT
assert len(result['dns']) == DEFAULT_BROKER_COUNT
for port in result['address']:
assert int(port.split(':')[-1]) != 9092
for port in result['dns']:
assert int(port.split(':')[-1]) != 9092
def test_topic_offsets_increase_with_writes():
offset_info = service_cli('topic offsets --time="-1" {}'.format(DEFAULT_TOPIC_NAME))
assert len(offset_info) == DEFAULT_PARTITION_COUNT
offsets = {}
for o in offset_info:
assert len(o) == DEFAULT_REPLICATION_FACTOR
offsets.update(o)
assert len(offsets) == DEFAULT_PARTITION_COUNT
num_messages = 10
write_info = service_cli('topic producer_test {} {}'.format(DEFAULT_TOPIC_NAME, num_messages))
assert len(write_info) == 1
assert write_info['message'].startswith('Output: {} records sent'.format(num_messages))
offset_info = service_cli('topic offsets --time="-1" {}'.format(DEFAULT_TOPIC_NAME))
assert len(offset_info) == DEFAULT_PARTITION_COUNT
post_write_offsets = {}
for offsets in offset_info:
assert len(o) == DEFAULT_REPLICATION_FACTOR
post_write_offsets.update(o)
assert not offsets == post_write_offsets
def test_topic_partition_count():
test_utils.service_cli('topic create {}'.format(DEFAULT_TOPIC_NAME),
service_name=FOLDERED_SERVICE_NAME)
topic_info = test_utils.service_cli(
'topic describe {}'.format(DEFAULT_TOPIC_NAME),
service_name=FOLDERED_SERVICE_NAME)
assert len(topic_info['partitions']) == config.DEFAULT_PARTITION_COUNT
def test_topic_delete():
delete_info = service_cli('topic delete {}'.format(EPHEMERAL_TOPIC_NAME))
assert len(delete_info) == 1
assert delete_info['message'].startswith('Output: Topic {} is marked for deletion'.format(EPHEMERAL_TOPIC_NAME))
topic_info = service_cli('topic describe {}'.format(EPHEMERAL_TOPIC_NAME))
assert len(topic_info) == 1
assert len(topic_info['partitions']) == DEFAULT_PARTITION_COUNT
def test_pod_cli():
assert test_utils.service_cli('pod list',
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('pod status {}-0'.format(
config.DEFAULT_POD_TYPE),
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('pod info {}-0'.format(
config.DEFAULT_POD_TYPE),
service_name=FOLDERED_SERVICE_NAME,
print_output=False) # noisy output
def test_broker_invalid():
try:
test_utils.service_cli(
'broker get {}'.format(config.DEFAULT_BROKER_COUNT + 1),
service_name=FOLDERED_SERVICE_NAME)
assert False, "Should have failed"
except AssertionError as arg:
raise arg
except:
pass # expected to fail
def test_topic_create():
create_info = service_cli(
'topic create {}'.format(EPHEMERAL_TOPIC_NAME)
)
utils.out(create_info)
assert ('Created topic "%s".\n' % EPHEMERAL_TOPIC_NAME in create_info['message'])
assert ("topics with a period ('.') or underscore ('_') could collide." in create_info['message'])
topic_list_info = service_cli('topic list')
assert topic_list_info == [EPHEMERAL_TOPIC_NAME]
topic_info = service_cli('topic describe {}'.format(EPHEMERAL_TOPIC_NAME))
assert len(topic_info) == 1
assert len(topic_info['partitions']) == DEFAULT_PARTITION_COUNT
def test_config_cli():
config_list = test_utils.service_cli('config list',
service_name=FOLDERED_SERVICE_NAME)
assert len(
config_list
) >= 1 # refrain from breaking this test if earlier tests did a config update
assert test_utils.service_cli('config show {}'.format(config_list[0]),
service_name=FOLDERED_SERVICE_NAME,
print_output=False) # noisy output
assert test_utils.service_cli('config target',
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('config target_id',
service_name=FOLDERED_SERVICE_NAME)
def test_canary_second():
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME, DEFAULT_PHASE_NAME))
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_count_check(DEFAULT_BROKER_COUNT)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'COMPLETE'
assert pl['phases'][0]['status'] == 'COMPLETE'
for step in range(DEFAULT_BROKER_COUNT):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
def fun():
ret = test_utils.service_cli('endpoints {}'.format(
config.DEFAULT_TASK_NAME),
service_name=FOLDERED_SERVICE_NAME)
if len(ret['address']) == config.DEFAULT_BROKER_COUNT:
return ret
return False
def test_no_under_replicated_topics_exist():
partition_info = test_utils.service_cli(
'topic under_replicated_partitions',
service_name=FOLDERED_SERVICE_NAME)
assert len(partition_info) == 1
assert partition_info['message'] == ''
def test_pods_restart():
for i in range(DEFAULT_BROKER_COUNT):
broker_id = tasks.get_task_ids(SERVICE_NAME,'{}-{}-{}'.format(DEFAULT_POD_TYPE, i, DEFAULT_TASK_NAME))
restart_info = service_cli('pods restart {}-{}'.format(DEFAULT_POD_TYPE, i))
tasks.check_tasks_updated(SERVICE_NAME, '{}-{}-{}'.format(DEFAULT_POD_TYPE, i, DEFAULT_TASK_NAME), broker_id)
assert len(restart_info) == 2
assert restart_info['tasks'][0] == '{}-{}-{}'.format(DEFAULT_POD_TYPE, i, DEFAULT_TASK_NAME)
def test_upgrade():
test_version = upgrade.get_pkg_version(PACKAGE_NAME)
utils.out('Found test version: {}'.format(test_version))
repositories = json.loads(
cmd.run_cli('package repo list --json'))['repositories']
utils.out("Repositories: " + str(repositories))
if len(repositories) < 2:
utils.out(
"There is only one version in the repository. Skipping upgrade test!"
)
assert repo[0]['name'] == 'Universe'
return
test_repo_name, test_repo_url = upgrade.get_test_repo_info()
for repo in repositories:
if repo['name'] != 'Universe':
shakedown.remove_package_repo(repo['name'])
universe_version = upgrade.get_pkg_version(PACKAGE_NAME)
utils.out('Found Universe version: {}'.format(universe_version))
utils.out('Installing Universe version: {}'.format(universe_version))
install.install(PACKAGE_NAME, DEFAULT_BROKER_COUNT)
utils.out('Installation complete for Universe version: {}'.format(
universe_version))
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = tasks.get_task_ids(SERVICE_NAME, 'broker-')
utils.out(
'Adding test version to repository with name: {} and url: {}'.format(
test_repo_name, test_repo_url))
upgrade.add_repo(test_repo_name, test_repo_url, universe_version, 0,
PACKAGE_NAME)
utils.out('Upgrading to test version: {}'.format(test_version))
marathon.destroy_app(SERVICE_NAME)
utils.out('Installing test version: {}'.format(test_version))
# installation will return with old tasks because they are still running
install.install(PACKAGE_NAME, DEFAULT_BROKER_COUNT)
utils.out(
'Installation complete for test version: {}'.format(test_version))
# wait till tasks are restarted
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE),
broker_ids)
utils.out('All task are restarted')
# all tasks are running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
address = service_cli('endpoints {}'.format(DEFAULT_TASK_NAME))
assert len(address) == 3
assert len(address['dns']) == DEFAULT_BROKER_COUNT
assert len(address['address']) == DEFAULT_BROKER_COUNT
def plan_waiting():
try:
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
if pl['status'] == 'WAITING':
return True
except:
pass
return False
def test_tls_endpoints(kafka_service_tls):
endpoints = sdk_networks.get_and_test_endpoints("", config.PACKAGE_NAME, 2)
assert BROKER_TLS_ENDPOINT in endpoints
# Test that broker-tls endpoint is available
endpoint_tls = service_cli(
'endpoints {name}'.format(name=BROKER_TLS_ENDPOINT))
assert len(endpoint_tls['dns']) == config.DEFAULT_BROKER_COUNT
def test_producer_over_tls(kafka_service_tls):
service_cli('topic create {}'.format(config.DEFAULT_TOPIC_NAME))
topic_info = service_cli('topic describe {}'.format(
config.DEFAULT_TOPIC_NAME))
assert len(topic_info['partitions']) == config.DEFAULT_PARTITION_COUNT
# Warm up TLS connections
write_info = service_cli('topic producer_test_tls {} {}'.format(
config.DEFAULT_TOPIC_NAME, 10))
num_messages = 10
write_info = service_cli('topic producer_test_tls {} {}'.format(
config.DEFAULT_TOPIC_NAME, num_messages))
assert len(write_info) == 1
assert write_info['message'].startswith(
'Output: {} records sent'.format(num_messages))
def plan_complete():
try:
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
if pl['status'] == 'COMPLETE':
return True
except:
pass
return False
def test_plan_cli():
assert test_utils.service_cli('plan list',
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan show {}'.format(
config.DEFAULT_PLAN_NAME),
get_json=False,
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan show --json {}'.format(
config.DEFAULT_PLAN_NAME),
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan show {} --json'.format(
config.DEFAULT_PLAN_NAME),
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan force-restart {}'.format(
config.DEFAULT_PLAN_NAME),
get_json=False,
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan interrupt {} {}'.format(
config.DEFAULT_PLAN_NAME, config.DEFAULT_PHASE_NAME),
get_json=False,
service_name=FOLDERED_SERVICE_NAME)
assert test_utils.service_cli('plan continue {} {}'.format(
config.DEFAULT_PLAN_NAME, config.DEFAULT_PHASE_NAME),
get_json=False,
service_name=FOLDERED_SERVICE_NAME)
def test_increasing_topic_partitions_succeeds():
partition_info = service_cli('topic partitions {} {}'.format(
DEFAULT_TOPIC_NAME, DEFAULT_PARTITION_COUNT + 1))
assert len(partition_info) == 1
assert partition_info['message'].startswith(
'Output: WARNING: If partitions are increased')
assert ('The number of partitions for a topic can only be increased'
not in partition_info['message'])
def test_setting_topic_partitions_to_same_value_fails():
partition_info = test_utils.service_cli('topic partitions {} {}'.format(
DEFAULT_TOPIC_NAME, config.DEFAULT_PARTITION_COUNT),
service_name=FOLDERED_SERVICE_NAME)
assert len(partition_info) == 1
assert partition_info['message'].startswith(
'Output: WARNING: If partitions are increased')
assert ('The number of partitions for a topic can only be increased'
in partition_info['message'])
def test_canary_first():
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME, DEFAULT_PHASE_NAME))
tasks.check_running(SERVICE_NAME, 1)
broker_count_check(1)
# do not use service_plan always
# when here, plan should always return properly
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][0]['status'] == 'COMPLETE'
assert pl['phases'][0]['steps'][1]['status'] == 'WAITING'
if DEFAULT_BROKER_COUNT >2:
assert pl['phases'][0]['steps'][2]['status'] == 'PENDING'
def test_canary_init():
pl = service_plan_wait(DEFAULT_PLAN_NAME)
brokers = service_cli('broker list')
assert brokers == []
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][1]['status'] == 'WAITING'
if DEFAULT_BROKER_COUNT > 2:
assert pl['phases'][0]['steps'][2]['status'] == 'PENDING'
def test_placement_max_one_per_hostname():
install.install(
PACKAGE_NAME,
DEFAULT_BROKER_COUNT,
service_name=SERVICE_NAME,
additional_options={'service':{'placement_constraint':'hostname:MAX_PER:1'}}
)
# double check
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'COMPLETE'
install.uninstall(SERVICE_NAME, PACKAGE_NAME)
def test_port_static_to_static_port():
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = tasks.get_task_ids(SERVICE_NAME,
'{}-'.format(DEFAULT_POD_TYPE))
config = marathon.get_config(SERVICE_NAME)
print('Old Config :{}'.format(config))
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9092
result = service_cli('endpoints broker')
assert len(result['native']) == DEFAULT_BROKER_COUNT
assert len(result['direct']) == DEFAULT_BROKER_COUNT
for port in result['native']:
assert int(port.split(':')[-1]) == 9092
for port in result['direct']:
assert int(port.split(':')[-1]) == 9092
config['env']['BROKER_PORT'] = '9095'
marathon.update_app(SERVICE_NAME, config)
print('New Config :{}'.format(config))
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE),
broker_ids)
# all tasks are running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
result = service_cli('endpoints broker')
assert len(result['native']) == DEFAULT_BROKER_COUNT
assert len(result['direct']) == DEFAULT_BROKER_COUNT
for port in result['native']:
assert int(port.split(':')[-1]) == 9095
for port in result['direct']:
assert int(port.split(':')[-1]) == 9095
def test_canary_init():
pl = service_plan_wait(DEFAULT_PLAN_NAME)
brokers = service_cli('broker list')
assert brokers == []
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][1]['status'] == 'WAITING'
if DEFAULT_BROKER_COUNT > 2:
assert pl['phases'][0]['steps'][2]['status'] == 'PENDING'
def test_increase_count():
marathon.bump_task_count_config(SERVICE_NAME, 'BROKER_COUNT')
try:
tasks.check_running(PACKAGE_NAME,
DEFAULT_BROKER_COUNT + 1,
timeout_seconds=60)
assert False, "Should not start task now"
except AssertionError as arg:
raise arg
except:
pass # expected to fail
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
for step in range(DEFAULT_BROKER_COUNT):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
assert pl['phases'][0]['steps'][DEFAULT_BROKER_COUNT][
'status'] == 'WAITING'
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME,
DEFAULT_PHASE_NAME))
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT + 1)
broker_count_check(DEFAULT_BROKER_COUNT + 1)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'COMPLETE'
assert pl['phases'][0]['status'] == 'COMPLETE'
for step in range(DEFAULT_BROKER_COUNT + 1):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
def test_port_static_to_static_port():
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = tasks.get_task_ids(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE))
config = marathon.get_config(SERVICE_NAME)
print('Old Config :{}'.format(config))
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9092
config['env']['BROKER_PORT'] = '9095'
marathon.update_app(SERVICE_NAME, config)
print('New Config :{}'.format(config))
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE), broker_ids)
# all tasks are running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
for broker_id in range(DEFAULT_BROKER_COUNT):
result = service_cli('broker get {}'.format(broker_id))
assert result['port'] == 9095
def test_increase_count():
config = marathon.get_config(SERVICE_NAME)
config['env']['BROKER_COUNT'] = str(int(config['env']['BROKER_COUNT']) + 1)
marathon.update_app(SERVICE_NAME, config)
try:
tasks.check_running(PACKAGE_NAME, DEFAULT_BROKER_COUNT + 1, timeout_seconds=60)
assert False, "Should not start task now"
except AssertionError as arg:
raise arg
except:
pass # expected to fail
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
for step in range(DEFAULT_BROKER_COUNT):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
assert pl['phases'][0]['steps'][DEFAULT_BROKER_COUNT]['status'] == 'WAITING'
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME, DEFAULT_PHASE_NAME))
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT + 1)
broker_count_check(DEFAULT_BROKER_COUNT + 1)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'COMPLETE'
assert pl['phases'][0]['status'] == 'COMPLETE'
for step in range(DEFAULT_BROKER_COUNT + 1):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
def test_can_adjust_config_from_dynamic_to_static_port():
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
broker_ids = tasks.get_task_ids(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE))
config = marathon.get_config(SERVICE_NAME)
config['env']['BROKER_PORT'] = '9092'
marathon.update_app(SERVICE_NAME, config)
tasks.check_tasks_updated(SERVICE_NAME, '{}-'.format(DEFAULT_POD_TYPE), broker_ids)
# all tasks are running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT)
result = service_cli('endpoints broker')
assert len(result['native']) == DEFAULT_BROKER_COUNT
assert len(result['direct']) == DEFAULT_BROKER_COUNT
for port in result['native']:
assert int(port.split(':')[-1]) == 9092
for port in result['direct']:
assert int(port.split(':')[-1]) == 9092
def test_increase_cpu():
def plan_waiting():
try:
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
if pl['status'] == 'WAITING':
return True
except:
pass
return False
def plan_complete():
try:
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
if pl['status'] == 'COMPLETE':
return True
except:
pass
return False
config = marathon.get_config(SERVICE_NAME)
config['env']['BROKER_CPUS'] = str(0.1 + float(config['env']['BROKER_CPUS']))
marathon.update_app(SERVICE_NAME, config)
spin.time_wait_return(plan_waiting)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][1]['status'] == 'WAITING'
for step in range (2, DEFAULT_BROKER_COUNT +1 ):
assert pl['phases'][0]['steps'][step]['status'] == 'PENDING'
# all tasks are still running
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT + 1)
broker_ids = tasks.get_task_ids(SERVICE_NAME, '{}-0-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME))
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME, DEFAULT_PHASE_NAME))
tasks.check_tasks_updated(SERVICE_NAME, '{}-0-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME), broker_ids)
tasks.check_running(SERVICE_NAME, DEFAULT_BROKER_COUNT + 1)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'WAITING'
assert pl['phases'][0]['status'] == 'WAITING'
assert pl['phases'][0]['steps'][0]['status'] == 'COMPLETE'
assert pl['phases'][0]['steps'][1]['status'] == 'WAITING'
for step in range(2, DEFAULT_BROKER_COUNT + 1):
assert pl['phases'][0]['steps'][step]['status'] == 'PENDING'
broker_ids = tasks.get_task_ids(SERVICE_NAME, '{}-1-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME))
service_cli('plan continue {} {}'.format(DEFAULT_PLAN_NAME, DEFAULT_PHASE_NAME))
tasks.check_tasks_updated(SERVICE_NAME, '{}-1-{}'.format(DEFAULT_POD_TYPE, DEFAULT_TASK_NAME), broker_ids)
spin.time_wait_return(plan_complete)
pl = service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
assert pl['status'] == 'COMPLETE'
assert pl['phases'][0]['status'] == 'COMPLETE'
for step in range(DEFAULT_BROKER_COUNT + 1):
assert pl['phases'][0]['steps'][step]['status'] == 'COMPLETE'
broker_count_check(DEFAULT_BROKER_COUNT + 1)
def fun():
try:
return service_cli('plan show {}'.format(DEFAULT_PLAN_NAME))
except:
return False
