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'], 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'], 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'] = 'KB.proxy' if \ not self.tenants_list['client'] else self.testing_kloud.flavor_to_use 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, kb_vm_agent.get_image_version()) elif self.multicast_mode: self.kb_runner = KBRunner_Multicast(client_list, self.client_cfg, kb_vm_agent.get_image_version(), self.single_cloud) else: self.kb_runner = KBRunner_HTTP(client_list, self.client_cfg, kb_vm_agent.get_image_version(), 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 total_vm = self.get_tenant_vm_count(self.client_cfg) 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()
def run(self): """ The runner for KloudBuster Tests """ vm_creation_concurrency = self.client_cfg.vm_creation_concurrency try: tenant_quota = self.calc_tenant_quota() self.kloud.create_resources(tenant_quota['server']) self.testing_kloud.create_resources(tenant_quota['client']) # Start the runner and ready for the incoming redis messages client_list = self.testing_kloud.get_all_instances() server_list = self.kloud.get_all_instances() # Setting up the KloudBuster Proxy node 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'] = 'kb.proxy' if \ not self.tenants_list['client'] else self.testing_kloud.flavor_to_use if self.topology: proxy_hyper = self.topology.clients_rack.split()[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) self.kb_runner = KBRunner(client_list, self.client_cfg, kb_vm_agent.get_image_version(), self.single_cloud) self.kb_runner.setup_redis(self.kb_proxy.fip_ip) if self.single_cloud: # 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 self.client_vm_create_thread = threading.Thread(target=self.testing_kloud.create_vms, args=[vm_creation_concurrency]) self.server_vm_create_thread = threading.Thread(target=self.kloud.create_vms, args=[vm_creation_concurrency]) self.client_vm_create_thread.daemon = True self.server_vm_create_thread.daemon = True if self.single_cloud: self.gen_user_data("Server") self.server_vm_create_thread.start() self.server_vm_create_thread.join() self.gen_user_data("Client") self.client_vm_create_thread.start() self.client_vm_create_thread.join() else: self.gen_user_data("Server") self.gen_user_data("Client") self.server_vm_create_thread.start() self.client_vm_create_thread.start() self.server_vm_create_thread.join() self.client_vm_create_thread.join() # Function that print all the provisioning info self.print_provision_info() # Run the runner to perform benchmarkings self.kb_runner.run() self.final_result = self.kb_runner.tool_result self.final_result['total_server_vms'] = len(server_list) self.final_result['total_client_vms'] = len(client_list) # self.final_result['host_stats'] = self.kb_runner.host_stats LOG.info(self.final_result) except KeyboardInterrupt: traceback.format_exc() except (ClientException, Exception): traceback.print_exc() # Cleanup: start with tested side first # then testing side last (order is important because of the shared network) if self.server_cfg['cleanup_resources']: try: self.kloud.delete_resources() except Exception: traceback.print_exc() KBResLogger.dump_and_save('svr', self.kloud.res_logger.resource_list) if self.client_cfg['cleanup_resources']: try: self.testing_kloud.delete_resources() except Exception: traceback.print_exc() KBResLogger.dump_and_save('clt', self.testing_kloud.res_logger.resource_list)