def stage(self):
"""
Staging all resources for running KloudBuster Tests
"""
vm_creation_concurrency = self.client_cfg.vm_creation_concurrency
tenant_quota = self.calc_tenant_quota()
if not self.storage_mode:
self.kloud = Kloud(self.server_cfg,
self.server_cred,
self.tenants_list['server'],
self.server_vm_img,
storage_mode=self.storage_mode,
multicast_mode=self.multicast_mode)
self.server_vm_create_thread = threading.Thread(
target=self.kloud.create_vms, args=[vm_creation_concurrency])
self.server_vm_create_thread.daemon = True
self.testing_kloud = Kloud(self.client_cfg,
self.client_cred,
self.tenants_list['client'],
self.client_vm_img,
testing_side=True,
storage_mode=self.storage_mode,
multicast_mode=self.multicast_mode)
self.client_vm_create_thread = threading.Thread(
target=self.testing_kloud.create_vms,
args=[vm_creation_concurrency])
self.client_vm_create_thread.daemon = True
if not self.storage_mode:
self.kloud.create_resources(tenant_quota['server'])
self.testing_kloud.create_resources(tenant_quota['client'])
# Setting up the KloudBuster Proxy node
client_list = self.testing_kloud.get_all_instances()
self.kb_proxy = client_list[-1]
client_list.pop()
self.kb_proxy.vm_name = 'KB-PROXY'
self.kb_proxy.user_data['role'] = 'KB-PROXY'
self.kb_proxy.boot_info['flavor_type'] = FLAVOR_KB_PROXY
if self.topology:
proxy_hyper = self.topology.clients_rack[0]
self.kb_proxy.boot_info['avail_zone'] = \
"%s:%s" % (self.testing_kloud.placement_az, proxy_hyper) \
if self.testing_kloud.placement_az else "nova:%s" % (proxy_hyper)
self.kb_proxy.boot_info['user_data'] = str(self.kb_proxy.user_data)
self.testing_kloud.create_vm(self.kb_proxy)
if self.storage_mode:
self.kb_runner = KBRunner_Storage(client_list, self.client_cfg)
elif self.multicast_mode:
self.kb_runner = KBRunner_Multicast(client_list, self.client_cfg,
self.single_cloud)
else:
self.kb_runner = KBRunner_HTTP(client_list, self.client_cfg,
self.single_cloud)
self.kb_runner.setup_redis(self.kb_proxy.fip_ip
or self.kb_proxy.fixed_ip)
if self.client_cfg.progression['enabled'] and not self.multicast_mode:
log_info = "Progression run is enabled, KloudBuster will schedule " \
"multiple runs as listed:"
stage = 1
start = self.client_cfg.progression.vm_start
multiple = self.client_cfg.progression.vm_multiple
cur_vm_count = 1 if start else multiple
# Minus 1 for KB-Proxy
total_vm = self.get_tenant_vm_count(self.client_cfg) - 1
while (cur_vm_count <= total_vm):
log_info += "\n" + self.kb_runner.header_formatter(
stage, cur_vm_count)
cur_vm_count = (stage + 1 - start) * multiple
stage += 1
LOG.info(log_info)
if self.single_cloud and not self.storage_mode and not self.multicast_mode:
# Find the shared network if the cloud used to testing is same
# Attach the router in tested kloud to the shared network
shared_net = self.testing_kloud.get_first_network()
self.kloud.attach_to_shared_net(shared_net)
# Create VMs in both tested and testing kloud concurrently
user_data_mode = "multicast" if self.multicast_mode else "http"
if self.storage_mode:
self.gen_client_user_data("storage")
self.client_vm_create_thread.start()
self.client_vm_create_thread.join()
elif self.single_cloud:
self.gen_server_user_data(user_data_mode)
self.server_vm_create_thread.start()
self.server_vm_create_thread.join()
self.gen_client_user_data(user_data_mode)
self.client_vm_create_thread.start()
self.client_vm_create_thread.join()
else:
self.gen_server_user_data(user_data_mode)
self.gen_client_user_data(user_data_mode)
self.server_vm_create_thread.start()
self.client_vm_create_thread.start()
self.server_vm_create_thread.join()
self.client_vm_create_thread.join()
if self.testing_kloud and self.testing_kloud.exc_info:
raise self.testing_kloud.exc_info[
1], None, self.testing_kloud.exc_info[2]
if self.kloud and self.kloud.exc_info:
raise self.kloud.exc_info[1], None, self.kloud.exc_info[2]
# Function that print all the provisioning info
self.print_provision_info()
