def is_successfully_finished(self, silent_failure=False, *tasks): view = navigate_to(self, self.tab) tab_view = getattr(view.tabs, self.tab.lower()) rows = [] # expected_status support also regular expression pattern expected_status = re.compile('finished', re.IGNORECASE) for task in tasks: try: rows.append(list(tab_view.table.rows(task_name=task, state=expected_status)).pop()) except IndexError: logger.warn('IndexError exception suppressed when searching for task row,' ' no match found.') return False for row in rows: message = row.message.text.lower() if row[1].browser.is_displayed('i[@class="pficon pficon-error-circle-o"]', parent=row[1]): if silent_failure: logger.warning("Task {} error: {}".format(row.task_name.text, message)) return False elif 'timed out' in message: raise TimedOutError("Task {} timed out: {}".format(row.task_name.text, message)) else: Exception("Task {} error: {}".format(row.task_name.text, message)) return True
def hostname(self, value): if self.default_endpoint: if value: self.default_endpoint.hostname = value else: logger.warn( "can't set hostname because default endpoint is absent")
def add_disk_to_vm(self): """Add a disk with specs from cfme_data.template_upload Generally for database disk """ temp_vm = self.mgmt.get_vm(self.temp_vm_name) if temp_vm.get_disks_count() > 1: logger.warn( '%s Warning: found more than one disk in existing VM (%s).', self.provider_key, self.temp_vm_name) return rhevm_specs = cfme_data.template_upload.template_upload_rhevm disk_kwargs = dict( storage_domain=self.provider_data.template_upload.sdomain, size=rhevm_specs.disk_size, interface=rhevm_specs.disk_interface, format=rhevm_specs.disk_format) temp_vm.add_disk(**disk_kwargs) # check, if there are two disks if temp_vm.get_disks_count() < 2: raise TemplateUploadException( '%s disk failed to add with specs: %r', self.provider_key, disk_kwargs) logger.info('%s:%s Successfully added disk', self.provider_key, self.temp_vm_name) return True
def create_on_provider(self, timeout=900, find_in_cfme=False, delete_on_failure=True, **kwargs): """Create the VM on the provider via MgmtSystem. `deploy_template` handles errors during VM provision on MgmtSystem sideNS deletes VM if provisioned incorrectly Args: timeout: Number of seconds to wait for the VM to appear in CFME Will not wait at all, if set to 0 (Defaults to ``900``) find_in_cfme: Verifies that VM exists in CFME UI delete_on_failure: Attempts to remove VM on UI navigation failure """ vm = deploy_template(self.provider.key, self.name, self.template_name, **kwargs) try: if find_in_cfme: self.wait_to_appear(timeout=timeout, load_details=False) except Exception as e: logger.warn("Couldn't find VM or Instance '%s' in CFME", self.name) if delete_on_failure: logger.info("Removing VM or Instance from mgmt system") self.cleanup_on_provider() raise e return vm
def from_config(cls): bz_conf = env.get('bugzilla', {}) # default empty so we can call .get() later url = bz_conf.get('url') if url is None: url = 'https://bugzilla.redhat.com/xmlrpc.cgi' logger.warning("No Bugzilla URL specified in conf, using default: %s", url) cred_key = bz_conf.get("credentials") bz_kwargs = dict( url=url, cookiefile=None, tokenfile=None, product=bz_conf.get("bugzilla", {}).get("product"), config_options=bz_conf) if cred_key: bz_creds = credentials.get(cred_key, {}) if bz_creds.get('username'): logger.info('Using username/password for Bugzilla authentication') bz_kwargs.update(dict( user=bz_creds.get("username"), password=bz_creds.get("password") )) elif bz_creds.get('api_key'): logger.info('Using api key for Bugzilla authentication') bz_kwargs.update(dict(api_key=bz_creds.get('api_key'))) else: logger.error('Credentials key for bugzilla does not have username or api key') else: logger.warn('No credentials found for bugzilla') return cls(**bz_kwargs)
def is_task_finished(destination, task_name, expected_status, clear_tasks_after_success=True): view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) # task_name change from str to support also regular expression pattern task_name = re.compile(task_name) # expected_status change from str to support also regular expression pattern expected_status = re.compile(expected_status, re.IGNORECASE) try: row = tab_view.table.row(task_name=task_name, state=expected_status) except IndexError: logger.warn('IndexError exception suppressed when searching for task row, no match found.') return False # throw exception if error in message message = row.message.text.lower() if 'error' in message: raise Exception("Task {} error: {}".format(task_name, message)) elif 'timed out' in message: raise TimedOutError("Task {} timed out: {}".format(task_name, message)) elif 'failed' in message: raise Exception("Task {} has a failure: {}".format(task_name, message)) if clear_tasks_after_success: # Remove all finished tasks so they wouldn't poison other tests delete_all_tasks(destination) return True
def is_task_finished(destination, task_name, expected_status, clear_tasks_after_success=True): view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) try: row = tab_view.table.row(task_name=task_name, state=expected_status) except IndexError: logger.warn( 'IndexError exception suppressed when searching for task row, no match found.' ) return False # throw exception if error in message message = row.message.text.lower() if 'error' in message: raise Exception("Task {} error: {}".format(task_name, message)) elif 'timed out' in message: raise TimedOutError("Task {} timed out: {}".format(task_name, message)) elif 'failed' in message: raise Exception("Task {} has a failure: {}".format(task_name, message)) if clear_tasks_after_success: # Remove all finished tasks so they wouldn't poison other tests delete_all_tasks(destination) return True
def ip_address(self, value): if self.default_endpoint: if value: self.default_endpoint.ipaddress = value else: logger.warn( "can't set ipaddress because default endpoint is absent")
def is_successfully_finished(self, silent_failure=False, *tasks): view = navigate_to(self, self.tab) tab_view = getattr(view.tabs, self.tab.lower()) rows = [] # expected_status support also regular expression pattern expected_status = re.compile('finished', re.IGNORECASE) for task in tasks: try: rows.append( list( tab_view.table.rows(task_name=task, state=expected_status)).pop()) except IndexError: logger.warn( 'IndexError exception suppressed when searching for task row,' ' no match found.') return False for row in rows: message = row.message.text.lower() if row[1].browser.is_displayed( 'i[@class="pficon pficon-error-circle-o"]', parent=row[1]): if silent_failure: logger.warning("Task {} error: {}".format( row.task_name.text, message)) return False elif 'timed out' in message: raise TimedOutError("Task {} timed out: {}".format( row.task_name.text, message)) else: Exception("Task {} error: {}".format( row.task_name.text, message)) return True
def _delete_vm(self): if self.inst.provider.mgmt.does_vm_exist(self.inst.name): navigate_to(self.inst, 'Details') logger.info('%r will be deleted', self.inst.name) return self.inst.provider.mgmt.delete_vm(self.inst.name) else: logger.warn('%r is already not existing!', self.inst.name)
def _delete_vm(self): if self.inst.provider.mgmt.does_vm_exist(self.inst.name): navigate_to(self.inst, 'Details') logger.info('%r will be deleted', self.inst.name) return self.inst.provider.mgmt.delete_vm(self.inst.name) else: logger.warn('%r is already not existing!', self.inst.name)
def _check_timelines(self, target): """Navigate to the TL of the given target, select the category of the event and verify that the tl_event of the VMEvent is present. if will return the length of the array containing the events found in that timeline. Args: target: A entity where a Timeline is present ( VM, Host, Cluster...) Returns: The length of the array containing the event found on the Timeline of the target. """ timelines_view = navigate_to(target, 'Timelines') if isinstance(timelines_view, ServerDiagnosticsView): timelines_view = timelines_view.timelines timeline_filter = timelines_view.filter else: timeline_filter = timelines_view.filter for selected_option in timeline_filter.event_category.all_selected_options: timeline_filter.event_category.select_by_visible_text( selected_option) timeline_filter.event_category.select_by_visible_text(self.tl_category) timeline_filter.time_position.select_by_visible_text('centered') timeline_filter.apply.click() events_list = timelines_view.chart.get_events(self.tl_category) logger.debug('events_list: ', events_list) logger.info('Searching for event type: %r in timeline category: %r', self.event, self.tl_category) if not len(events_list): self.vm.provider.refresh_provider_relationships() logger.warn('Event list of %r is empty!', target) found_events = [] for evt in events_list: if hasattr(evt, 'destination_vm'): # Specially for the VmDeployedEvent where the source_vm defers from the # self.vm.name if evt.destination_vm == self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break elif not hasattr(evt, 'source_vm') or not hasattr( evt, 'source_host'): logger.warn( 'Event %r does not have source_vm, source_host. Probably an issue', evt) elif evt.source_vm == self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break logger.info('found events on {tgt}: {evt}'.format( tgt=target, evt="\n".join([repr(e) for e in found_events]))) return len(found_events)
def check_tasks_have_no_errors(task_name, task_type, expected_num_of_tasks, silent_failure=False, clear_tasks_after_success=False): """ Check if all tasks analysis match state with no errors""" tabs_data = TABS_DATA_PER_PROVIDER[task_type] destination = tabs_data['tab'] task_name = tabs_data['task'].format(task_name) expected_status = tabs_data['state'] view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) # task_name change from str to support also regular expression pattern task_name = re.compile(task_name) # expected_status change from str to support also regular expression pattern expected_status = re.compile(expected_status, re.IGNORECASE) try: rows = list( tab_view.table.rows(task_name=task_name, state=expected_status)) except IndexError: logger.warn( 'IndexError exception suppressed when searching for task row, no match found.' ) return False # check state for all tasks if expected_num_of_tasks != len(rows): logger.warn('There is no match between expected number of tasks "{}",' ' and number of tasks on state "{}'.format( expected_num_of_tasks, expected_status)) return False # throw exception if error in message for row in rows: message = row.message.text.lower() for term in ('error', 'timed out', 'failed', 'unable to run openscap'): if term in message: if silent_failure: logger.warning("Task {} error: {}".format( row.task_name.text, message)) return False elif term == 'timed out': raise TimedOutError("Task {} timed out: {}".format( row.task_name.text, message)) else: raise TaskFailedException(task_name=row.task_name.text, message=message) if clear_tasks_after_success: # Remove all finished tasks so they wouldn't poison other tests delete_all_tasks(destination) return True
def check_tasks_have_no_errors(task_name, task_type, expected_num_of_tasks, silent_failure=False, clear_tasks_after_success=False): """ Check if all tasks analysis match state with no errors""" tabs_data = TABS_DATA_PER_PROVIDER[task_type] destination = tabs_data['tab'] task_name = tabs_data['task'].format(task_name) expected_status = tabs_data['state'] view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) # task_name change from str to support also regular expression pattern task_name = re.compile(task_name) # expected_status change from str to support also regular expression pattern expected_status = re.compile(expected_status, re.IGNORECASE) wait_for( lambda: tab_view.table.is_displayed, timeout=10, delay=2, fail_func=view.reload.click ) try: rows = list(tab_view.table.rows(task_name=task_name, state=expected_status)) except IndexError: logger.warn('IndexError exception suppressed when searching for task row, no match found.') return False # check state for all tasks if expected_num_of_tasks != len(rows): logger.warn('There is no match between expected number of tasks "{}",' ' and number of tasks on state "{}'.format(expected_num_of_tasks, expected_status)) return False # throw exception if error in message for row in rows: message = row.message.text.lower() for term in ('error', 'timed out', 'failed', 'unable to run openscap'): if term in message: if silent_failure: logger.warning("Task {} error: {}".format(row.task_name.text, message)) return False elif term == 'timed out': raise TimedOutError("Task {} timed out: {}".format(row.task_name.text, message)) else: raise TaskFailedException(task_name=row.task_name.text, message=message) if clear_tasks_after_success: # Remove all finished tasks so they wouldn't poison other tests delete_all_tasks(destination) return True
def _check_timelines(self, target): """Navigate to the TL of the given target, select the category of the event and verify that the tl_event of the VMEvent is present. if will return the length of the array containing the events found in that timeline. Args: target: A entity where a Timeline is present ( VM, Host, Cluster...) Returns: The length of the array containing the event found on the Timeline of the target. """ timelines_view = navigate_to(target, 'Timelines') if isinstance(timelines_view, ServerDiagnosticsView): timelines_view = timelines_view.timelines timeline_filter = timelines_view.filter else: timeline_filter = timelines_view.filter for selected_option in timeline_filter.event_category.all_selected_options: timeline_filter.event_category.select_by_visible_text(selected_option) timeline_filter.event_category.select_by_visible_text(self.tl_category) timeline_filter.time_position.select_by_visible_text('centered') timeline_filter.apply.click() events_list = timelines_view.chart.get_events(self.tl_category) logger.debug('events_list: ', events_list) logger.info('Searching for event type: %r in timeline category: %r', self.event, self.tl_category) if not len(events_list): self.vm.provider.refresh_provider_relationships() logger.warn('Event list of %r is empty!', target) found_events = [] for evt in events_list: if hasattr(evt, 'destination_vm'): # Specially for the VmDeployedEvent where the source_vm defers from the # self.vm.name if evt.destination_vm == self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break elif not hasattr(evt, 'source_vm') or not hasattr(evt, 'source_host'): logger.warn('Event %r does not have source_vm, source_host. Probably an issue', evt) elif evt.source_vm == self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break logger.info('found events on {tgt}: {evt}'.format(tgt=target, evt="\n".join([repr(e) for e in found_events]))) return len(found_events)
def count_events(target, vm): timelines_view = navigate_to(target, 'Timelines') if isinstance(target, Server): timelines_view = timelines_view.timelines timelines_view.filter.time_position.select_by_visible_text('centered') timelines_view.filter.apply.click() found_events = [] for evt in timelines_view.chart.get_events(): if not hasattr(evt, 'source_vm'): # BZ(1428797) logger.warn("event {evt} doesn't have source_vm field. Probably issue".format(evt=evt)) continue elif evt.source_vm == vm.name: found_events.append(evt) logger.info("found events: {evt}".format(evt="\n".join([repr(e) for e in found_events]))) return len(found_events)
def all_tasks_match_status(destination, task_name, expected_status, expected_num_of_tasks): """ Check if all tasks with same task name states are finished - if not, reload page""" view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) # task_name change from str to support also regular expression pattern task_name = re.compile(task_name) # expected_status change from str to support also regular expression pattern expected_status = re.compile(expected_status, re.IGNORECASE) try: rows = list(tab_view.table.rows(task_name=task_name, state=expected_status)) except IndexError: logger.warn('IndexError exception suppressed when searching for task row, no match found.') return False # check state = finished for all tasks return expected_num_of_tasks == len(rows), len(rows)
def test_aws_smartstate_pod(temp_ssa_pod_appliance, ssa_vm, provider, aws_provider): """ deploy aws smartstate pod and that it works Polarion: assignee: izapolsk casecomponent: Containers caseimportance: medium initialEstimate: 1h testSteps: 1. pull smartstate image from registry 2. tag it accordingly and push to externally available registry 3. setup appliance to use that image for smartstate in aws 4. add aws provider 5. find 24/7 vm in aws and perform smartstate analysis """ appliance = temp_ssa_pod_appliance if BZ(1684203, forced_streams=['5.10']).blocks: logger.info( "stopping & starting appliance in order to re-read new AMI name") provider.mgmt.stop_vm(appliance.project) provider.mgmt.start_vm(appliance.project) provider.mgmt.wait_vm_running(appliance.project) for _ in range(3): try: # there is issue caused by unexpected log out and etc. this is workaround # it will be removed along with above BZ when it is fixed navigate_to(aws_provider, 'Details') break except Exception as e: logger.warn( "attempt to go to aws_provider failed with '{e}'".format( e=e.message)) # run SSA against cu24x7 vm ssa_vm.smartstate_scan(wait_for_task_result=True) # check SSA has been run and there are some results c_lastanalyzed = ssa_vm.last_analysed assert c_lastanalyzed != 'Never', "Last Analyzed is set to Never"
def create_on_provider(self, timeout=900, find_in_cfme=False, delete_on_failure=True, **kwargs): """Create the VM on the provider via MgmtSystem. `deploy_template` handles errors during VM provision on MgmtSystem sideNS deletes VM if provisioned incorrectly Args: timeout: Number of seconds to wait for the VM to appear in CFME Will not wait at all, if set to 0 (Defaults to ``900``) find_in_cfme: Verifies that VM exists in CFME UI delete_on_failure: Attempts to remove VM on UI navigation failure """ deploy_template(self.provider.key, self.name, self.template_name, **kwargs) try: if find_in_cfme: self.wait_to_appear(timeout=timeout, load_details=False) except Exception as e: logger.warn("Couldn't find VM or Instance in CMFE") if delete_on_failure: logger.info("Removing VM or Instance from mgmt system") self.provider.mgmt.delete_vm(self.name) raise e
def add_disk_to_vm(self): """Add a disk with specs from cfme_data.template_upload Generally for database disk """ temp_vm = self.mgmt.get_vm(self.temp_vm_name) if temp_vm.get_disks_count() > 1: logger.warn('%s Warning: found more than one disk in existing VM (%s).', self.provider_key, self.temp_vm_name) return rhevm_specs = cfme_data.template_upload.template_upload_rhevm disk_kwargs = dict(storage_domain=self.provider_data.template_upload.sdomain, size=rhevm_specs.disk_size, interface=rhevm_specs.disk_interface, format=rhevm_specs.disk_format) temp_vm.add_disk(**disk_kwargs) # check, if there are two disks if temp_vm.get_disks_count() < 2: raise TemplateUploadException('%s disk failed to add with specs: %r', self.provider_key, disk_kwargs) logger.info('%s:%s Successfully added disk', self.provider_key, self.temp_vm_name) return True
def checksum_verification(self): # Download checksum from url checksum = None try: response = request.urlopen('{}/SHA256SUM'.format(self.image_url)) checksums = response.read().decode('utf-8') for line in checksums.split("\n"): if self.image_name in line: checksum = line.strip().split()[0] except URLError: logger.warn('Failed download of checksum using urllib') if not checksum: logger.warn('Failed to get checksum of image from url') else: # Get checksum of downloaded file sha256 = hashlib.sha256() image_sha256 = None try: with open(self.image_name, 'rb') as f: for block in iter(lambda: f.read(65536), b''): sha256.update(block) image_sha256 = sha256.hexdigest() except Exception: logger.warn('Failed to get checksum of image') if image_sha256 and not checksum == image_sha256: logger.exception( 'Local image checksum does not match checksum from url') return False else: logger.info('Local image checksum matches checksum from url') return True
def test_aws_smartstate_pod(temp_ssa_pod_appliance, ssa_vm, provider, aws_provider): """ deploy aws smartstate pod and that it works Polarion: assignee: izapolsk casecomponent: Containers caseimportance: medium initialEstimate: 1h testSteps: 1. pull smartstate image from registry 2. tag it accordingly and push to externally available registry 3. setup appliance to use that image for smartstate in aws 4. add aws provider 5. find 24/7 vm in aws and perform smartstate analysis """ appliance = temp_ssa_pod_appliance if BZ(1684203, forced_streams=['5.10']).blocks: logger.info("stopping & starting appliance in order to re-read new AMI name") provider.mgmt.stop_vm(appliance.project) provider.mgmt.start_vm(appliance.project) provider.mgmt.wait_vm_running(appliance.project) for _ in range(3): try: # there is issue caused by unexpected log out and etc. this is workaround # it will be removed along with above BZ when it is fixed navigate_to(aws_provider, 'Details') break except Exception as e: logger.warn("attempt to go to aws_provider failed with '{e}'".format(e=e.message)) # run SSA against cu24x7 vm ssa_vm.smartstate_scan(wait_for_task_result=True) # check SSA has been run and there are some results c_lastanalyzed = ssa_vm.last_analysed assert c_lastanalyzed != 'Never', "Last Analyzed is set to Never"
def all_tasks_match_status(destination, task_name, expected_status, expected_num_of_tasks): """ Check if all tasks with same task name states are finished - if not, reload page""" view = navigate_to(Tasks, destination) tab_view = getattr(view.tabs, destination.lower()) # task_name change from str to support also regular expression pattern task_name = re.compile(task_name) # expected_status change from str to support also regular expression pattern expected_status = re.compile(expected_status, re.IGNORECASE) try: rows = list( tab_view.table.rows(task_name=task_name, state=expected_status)) except IndexError: logger.warn( 'IndexError exception suppressed when searching for task row, no match found.' ) return False # check state = finished for all tasks return expected_num_of_tasks == len(rows), len(rows)
def test_workload_smartstate_analysis(appliance, request, scenario): """Runs through provider based scenarios initiating smart state analysis against VMs, Hosts, and Datastores""" from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.install_vddk() appliance.clean_appliance() quantifiers = {} scenario_data = {'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-ssa', 'test_name': 'SmartState Analysis', 'appliance_roles': ', '.join(roles_smartstate), 'scenario': scenario} monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info('Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_smartstate}) for provider in scenario['providers']: get_crud(provider).create_rest() logger.info('Sleeping for Refresh: {}s'.format(scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) # Add host credentials and set CFME relationship for RHEVM SSA for provider in scenario['providers']: for api_host in appliance.rest_api.collections.hosts.all: host_collection = appliance.collections.hosts test_host = host_collection.instantiate(name=api_host.name, provider=provider) host_data = get_host_data_by_name(get_crud(provider), api_host.name) credentials = host.get_credentials_from_config(host_data['credentials']) test_host.update_credentials_rest(credentials) appliance.set_cfme_server_relationship(cfme_performance['appliance']['appliance_name']) # Variable amount of time for SmartState Analysis workload total_time = scenario['total_time'] starttime = time.time() time_between_analyses = scenario['time_between_analyses'] total_scanned_vms = 0 while ((time.time() - starttime) < total_time): start_ssa_time = time.time() for vm in scenario['vms_to_scan'].values()[0]: vm_api = appliance.rest_api.collections.vms.get(name=vm) vm_api.action.scan() total_scanned_vms += 1 iteration_time = time.time() ssa_time = round(iteration_time - start_ssa_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue SmartState Analyses: {}'.format(ssa_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if ssa_time < time_between_analyses: wait_diff = time_between_analyses - ssa_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_analyses): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn('Time to Queue SmartState Analyses ({}) exceeded time between ' '({})'.format(ssa_time, time_between_analyses)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Scans'] = total_scanned_vms logger.info('Test Ending...')
def _check_timelines(self, target, policy_events): """Verify that the event is present in the timeline Args: target: A entity where a Timeline is present (Instance, Availability zone, Provider...) policy_events: switch between the management event timeline and the policy timeline. Returns: The length of the array containing the event found on the Timeline of the target. """ def _get_timeline_events(target, policy_events): """Navigate to the timeline of the target and select the management timeline or the policy timeline. Returns an array of the found events. """ timelines_view = navigate_to(target, 'Timelines') if isinstance(timelines_view, ServerDiagnosticsView): timelines_view = timelines_view.timelines timeline_filter = timelines_view.filter if policy_events: logger.info('Will search in Policy event timelines') timelines_view.filter.event_type.select_by_visible_text('Policy Events') timeline_filter.policy_event_category.select_by_visible_text(self.tl_category) timeline_filter.policy_event_status.fill('Both') else: timeline_filter.detailed_events.fill(True) for selected_option in timeline_filter.event_category.all_selected_options: timeline_filter.event_category.select_by_visible_text(selected_option) timeline_filter.event_category.select_by_visible_text(self.tl_category) timeline_filter.time_position.select_by_visible_text('centered') timeline_filter.apply.click() logger.info('Searching for event type: %r in timeline category: %r', self.event, self.tl_category) return timelines_view.chart.get_events(self.tl_category) events_list = _get_timeline_events(target, policy_events) logger.debug('events_list: %r', str(events_list)) if not events_list: self.inst.provider.refresh_provider_relationships() logger.warn('Event list of %r is empty!', target) found_events = [] for evt in events_list: try: if not policy_events: if evt.source_instance in self.inst.name and evt.event_type in self.tl_event: found_events.append(evt) break else: if evt.event_type in self.tl_event and evt.target in self.inst.name: found_events.append(evt) break except AttributeError as err: logger.warn('Issue with TimelinesEvent: %r .Faulty event: %r', str(err), str(evt)) continue logger.info('found events on %r: %s', target, "\n".join([repr(e) for e in found_events])) return len(found_events)
def _finalize(): try: vm_obj.cleanup_on_provider() except Exception: logger.warn('Failed deleting VM from provider: %s', vm_name)
def test_provisioning(appliance, request, scenario): """Runs through provisioning scenarios using the REST API to continously provision a VM for a specified period of time. Memory Monitor creates graphs and summary at the end of each scenario.""" from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = {'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-provisioning', 'test_name': 'Provisioning', 'appliance_roles': ', '.join(roles_provisioning), 'scenario': scenario} monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) provision_order = [] def cleanup_workload(scenario, from_ts, vms_to_cleanup, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') appliance.update_server_roles({role: True for role in roles_provisioning_cleanup}) monitor_thread.grafana_urls = g_urls monitor_thread.signal = False final_vm_size = len(vms_to_cleanup) appliance.rest_api.collections.vms.action.delete(vms_to_cleanup) monitor_thread.join() logger.info('{} VMs were left over, and {} VMs were deleted in the finalizer.' .format(final_vm_size, final_vm_size - len(vms_to_cleanup))) logger.info('The following VMs were left over after the test: {}' .format(vms_to_cleanup)) quantifiers['VMs_To_Delete_In_Finalizer'] = final_vm_size quantifiers['VMs_Deleted_In_Finalizer'] = final_vm_size - len(vms_to_cleanup) quantifiers['Leftover_VMs'] = vms_to_cleanup add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info('Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, vm_name, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_provisioning}) prov = get_crud(scenario['providers'][0]) prov.create_rest() logger.info('Sleeping for Refresh: {}s'.format(scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) guid_list = prov.get_template_guids(scenario['templates']) guid_cycle = cycle(guid_list) cleanup_size = scenario['cleanup_size'] number_of_vms = scenario['number_of_vms'] total_time = scenario['total_time'] time_between_provision = scenario['time_between_provision'] total_provisioned_vms = 0 total_deleted_vms = 0 provisioned_vms = 0 starttime = time.time() while ((time.time() - starttime) < total_time): start_iteration_time = time.time() provision_list = [] for i in range(number_of_vms): total_provisioned_vms += 1 provisioned_vms += 1 vm_to_provision = '{}-provision-{}'.format( test_ts, str(total_provisioned_vms).zfill(4)) guid_to_provision, provider_name = next(guid_cycle) provision_order.append((vm_to_provision, provider_name)) provision_list.append((vm_to_provision, guid_to_provision, prov.data['provisioning']['vlan'])) template = prov.data.templates.get('small_template') provision_data = get_provision_data(appliance.rest_api, prov, template.name) vm_name = provision_data["vm_fields"]["vm_name"] response = appliance.rest_api.collections.provision_requests.action.create(**provision_data) assert appliance.rest_api.response.status_code == 200 provision_request = response[0] def _finished(): provision_request.reload() if "error" in provision_request.status.lower(): pytest.fail("Error when provisioning: `{}`".format(provision_request.message)) return provision_request.request_state.lower() in ("finished", "provisioned") wait_for(_finished, num_sec=800, delay=5, message="REST provisioning finishes") vm = appliance.rest_api.collections.vms.get(name=vm_name) creation_time = time.time() provision_time = round(creation_time - start_iteration_time, 2) logger.debug('Time to initiate provisioning: {}'.format(provision_time)) logger.info('{} VMs provisioned so far'.format(total_provisioned_vms)) if provisioned_vms > cleanup_size * len(scenario['providers']): start_remove_time = time.time() if appliance.rest_api.collections.vms.action.delete(vm): provision_order.pop(0) provisioned_vms -= 1 total_deleted_vms += 1 deletion_time = round(time.time() - start_remove_time, 2) logger.debug('Time to initate deleting: {}'.format(deletion_time)) logger.info('{} VMs deleted so far'.format(total_deleted_vms)) end_iteration_time = time.time() iteration_time = round(end_iteration_time - start_iteration_time, 2) elapsed_time = end_iteration_time - starttime logger.debug('Time to initiate provisioning and deletion: {}'.format(iteration_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if iteration_time < time_between_provision: wait_diff = time_between_provision - iteration_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_provision): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn('Time to initiate provisioning ({}) exceeded time between ' '({})'.format(iteration_time, time_between_provision)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Provisionings'] = total_provisioned_vms quantifiers['Deleted_VMs'] = total_deleted_vms logger.info('Provisioned {} VMs and deleted {} VMs during the scenario.' .format(total_provisioned_vms, total_deleted_vms)) logger.info('Test Ending...')
def _check_timelines(self, target, policy_events): """Verify that the event is present in the timeline Args: target: A entity where a Timeline is present (VM, host, cluster, Provider...) policy_events: switch between the management event timeline and the policy timeline. Returns: The length of the array containing the event found on the Timeline of the target. """ def _get_timeline_events(target, policy_events): """Navigate to the timeline of the target and select the management timeline or the policy timeline. Returns an array of the found events. """ timelines_view = navigate_to(target, 'Timelines') if isinstance(timelines_view, ServerDiagnosticsView): timelines_view = timelines_view.timelines timeline_filter = timelines_view.filter if policy_events: logger.info('Will search in Policy event timelines') timelines_view.filter.event_type.select_by_visible_text( 'Policy Events') timeline_filter.policy_event_category.select_by_visible_text( self.tl_category) timeline_filter.policy_event_status.fill('Both') else: timeline_filter.detailed_events.fill(True) for selected_option in timeline_filter.event_category.all_selected_options: timeline_filter.event_category.select_by_visible_text( selected_option) timeline_filter.event_category.select_by_visible_text( self.tl_category) timeline_filter.time_position.select_by_visible_text('centered') timeline_filter.apply.click() logger.info( 'Searching for event type: %r in timeline category: %r', self.event, self.tl_category) return timelines_view.chart.get_events(self.tl_category) events_list = _get_timeline_events(target, policy_events) logger.debug('events_list: %r', str(events_list)) if not len(events_list): self.vm.provider.refresh_provider_relationships() logger.warn('Event list of %r is empty!', str(target)) found_events = [] for evt in events_list: try: if not policy_events: # Special case for create event if hasattr(evt, 'destination_vm' ) and evt.destination_vm in self.vm.name: found_events.append(evt) break # Other events elif evt.source_vm in self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break else: if evt.event_type in self.tl_event and evt.target in self.vm.name: found_events.append(evt) break except AttributeError as err: logger.warn('Issue with TimelinesEvent: %r .Faulty event: %r', str(err), str(evt)) continue logger.info('found events on %r :\n %s', target, '\n'.join([repr(e) for e in found_events])) return len(found_events)
def hostname(self, value): if self.default_endpoint: if value: self.default_endpoint.hostname = value else: logger.warn("can't set hostname because default endpoint is absent")
def ip_address(self, value): if self.default_endpoint: if value: self.default_endpoint.ipaddress = value else: logger.warn("can't set ipaddress because default endpoint is absent")
def test_workload_smartstate_analysis(appliance, request, scenario): """Runs through provider based scenarios initiating smart state analysis against VMs, Hosts, and Datastores Polarion: assignee: rhcf3_machine initialEstimate: 1/4h """ from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.install_vddk() appliance.clean_appliance() quantifiers = {} scenario_data = { 'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-ssa', 'test_name': 'SmartState Analysis', 'appliance_roles': ', '.join(roles_smartstate), 'scenario': scenario } monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info( 'Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_smartstate}) for provider in scenario['providers']: get_crud(provider).create_rest() logger.info('Sleeping for Refresh: {}s'.format( scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) # Add host credentials and set CFME relationship for RHEVM SSA for provider in scenario['providers']: for api_host in appliance.rest_api.collections.hosts.all: host_collection = appliance.collections.hosts test_host = host_collection.instantiate(name=api_host.name, provider=provider) host_data = get_host_data_by_name(get_crud(provider), api_host.name) credentials = host.get_credentials_from_config( host_data['credentials']) test_host.update_credentials_rest(credentials) appliance.set_cfme_server_relationship( cfme_performance['appliance']['appliance_name']) # Variable amount of time for SmartState Analysis workload total_time = scenario['total_time'] starttime = time.time() time_between_analyses = scenario['time_between_analyses'] total_scanned_vms = 0 while ((time.time() - starttime) < total_time): start_ssa_time = time.time() for vm in scenario['vms_to_scan'].values()[0]: vm_api = appliance.rest_api.collections.vms.get(name=vm) vm_api.action.scan() total_scanned_vms += 1 iteration_time = time.time() ssa_time = round(iteration_time - start_ssa_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue SmartState Analyses: {}'.format(ssa_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if ssa_time < time_between_analyses: wait_diff = time_between_analyses - ssa_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_analyses): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn( 'Time to Queue SmartState Analyses ({}) exceeded time between ' '({})'.format(ssa_time, time_between_analyses)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Scans'] = total_scanned_vms logger.info('Test Ending...')
def _check_timelines(self, target, policy_events): """Verify that the event is present in the timeline Args: target: A entity where a Timeline is present (VM, host, cluster, Provider...) policy_events: switch between the management event timeline and the policy timeline. Returns: The length of the array containing the event found on the Timeline of the target. """ def _get_timeline_events(target, policy_events): """Navigate to the timeline of the target and select the management timeline or the policy timeline. Returns an array of the found events. """ timelines_view = navigate_to(target, 'Timelines') if isinstance(timelines_view, ServerDiagnosticsView): timelines_view = timelines_view.timelines timeline_filter = timelines_view.filter if policy_events: logger.info('Will search in Policy event timelines') timelines_view.filter.event_type.select_by_visible_text('Policy Events') timeline_filter.policy_event_category.select_by_visible_text(self.tl_category) timeline_filter.policy_event_status.fill('Both') else: if timelines_view.browser.product_version < "5.10": timeline_filter.detailed_events.fill(True) for selected_option in timeline_filter.event_category.all_selected_options: timeline_filter.event_category.select_by_visible_text(selected_option) timeline_filter.event_category.select_by_visible_text(self.tl_category) timeline_filter.time_position.select_by_visible_text('centered') timeline_filter.apply.click() logger.info('Searching for event type: %r in timeline category: %r', self.event, self.tl_category) return timelines_view.chart.get_events(self.tl_category) events_list = _get_timeline_events(target, policy_events) logger.debug('events_list: %r', str(events_list)) if not len(events_list): self.vm.provider.refresh_provider_relationships() logger.warn('Event list of %r is empty!', str(target)) found_events = [] for evt in events_list: try: if not policy_events: # Special case for create event if hasattr(evt, 'destination_vm') and evt.destination_vm in self.vm.name: found_events.append(evt) break # Other events elif evt.source_vm in self.vm.name and evt.event_type in self.tl_event: found_events.append(evt) break elif ( self.event == 'create' and BZ(1687493, unblock=lambda provider: not provider.one_of(RHEVMProvider)).blocks and self.vm.name in evt.message and evt.event_type in self.tl_event ): found_events.append(evt) break else: if evt.event_type in self.tl_event and evt.target in self.vm.name: found_events.append(evt) break except AttributeError as err: logger.warn('Issue with TimelinesEvent: %r .Faulty event: %r', str(err), str(evt)) continue logger.info('found events on %r :\n %s', target, '\n'.join([repr(e) for e in found_events])) return len(found_events)
def _finalize(): try: vm_obj.delete_from_provider() except Exception: logger.warn('Failed deleting VM from provider: %s', vm_name)
def test_refresh_vms(appliance, request, scenario): """Refreshes all vm's then waits for a specific amount of time. Memory Monitor creates graphs and summary at the end of the scenario.""" from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = { 'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-refresh-vm', 'test_name': 'Refresh VMs', 'appliance_roles': ', '.join(roles_refresh_vms), 'scenario': scenario } monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info( 'Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_refresh_vms}) for prov in scenario['providers']: get_crud(prov).create_rest() logger.info('Sleeping for refresh: {}s'.format( scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) full_refresh_threshold_set = False if 'full_refresh_threshold' in scenario: if scenario['full_refresh_threshold'] != FULL_REFRESH_THRESHOLD_DEFAULT: appliance.set_full_refresh_threshold( scenario['full_refresh_threshold']) full_refresh_threshold_set = True if not full_refresh_threshold_set: logger.debug('Keeping full_refresh_threshold at default ({}).'.format( FULL_REFRESH_THRESHOLD_DEFAULT)) refresh_size = scenario['refresh_size'] vms = appliance.rest_api.collections.vms.all vms_iter = cycle(vms) logger.debug('Number of VM IDs: {}'.format(len(vms))) # Variable amount of time for refresh workload total_time = scenario['total_time'] starttime = time.time() time_between_refresh = scenario['time_between_refresh'] total_refreshed_vms = 0 while ((time.time() - starttime) < total_time): start_refresh_time = time.time() refresh_list = [next(vms_iter) for x in range(refresh_size)] for vm in refresh_list: vm.action.reload() total_refreshed_vms += len(refresh_list) iteration_time = time.time() refresh_time = round(iteration_time - start_refresh_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue VM Refreshes: {}'.format(refresh_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if refresh_time < time_between_refresh: wait_diff = time_between_refresh - refresh_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_refresh): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn( 'Time to Queue VM Refreshes ({}) exceeded time between ' '({})'.format(refresh_time, time_between_refresh)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Refreshes'] = total_refreshed_vms logger.info('Test Ending...')
def test_refresh_providers(appliance, request, scenario): """ Refreshes providers then waits for a specific amount of time. Memory Monitor creates graphs and summary at the end of the scenario. Polarion: assignee: rhcf3_machine initialEstimate: 1/4h """ from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = { 'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-refresh-providers', 'test_name': 'Refresh Providers', 'appliance_roles': ', '.join(roles_refresh_providers), 'scenario': scenario } monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info('Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_refresh_providers}) for prov in scenario['providers']: get_crud(prov).create_rest() # Variable amount of time for refresh workload total_time = scenario['total_time'] starttime = time.time() time_between_refresh = scenario['time_between_refresh'] total_refreshed_providers = 0 while ((time.time() - starttime) < total_time): start_refresh_time = time.time() appliance.rest_api.collections.providers.reload() for prov in appliance.rest_api.collections.providers.all: prov.action.reload() total_refreshed_providers += 1 iteration_time = time.time() refresh_time = round(iteration_time - start_refresh_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue Refreshes: {}'.format(refresh_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if refresh_time < time_between_refresh: wait_diff = time_between_refresh - refresh_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_refresh): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn('Time to Queue Refreshes ({}) exceeded time between ' '({})'.format(refresh_time, time_between_refresh)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_Provider_Refreshes'] = total_refreshed_providers logger.info('Test Ending...')
def test_provisioning(appliance, request, scenario): """Runs through provisioning scenarios using the REST API to continously provision a VM for a specified period of time. Memory Monitor creates graphs and summary at the end of each scenario. Polarion: assignee: None initialEstimate: None """ from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = { 'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-provisioning', 'test_name': 'Provisioning', 'appliance_roles': ', '.join(roles_provisioning), 'scenario': scenario } monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) provision_order = [] def cleanup_workload(scenario, from_ts, vms_to_cleanup, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') appliance.update_server_roles( {role: True for role in roles_provisioning_cleanup}) monitor_thread.grafana_urls = g_urls monitor_thread.signal = False final_vm_size = len(vms_to_cleanup) appliance.rest_api.collections.vms.action.delete(vms_to_cleanup) monitor_thread.join() logger.info( '{} VMs were left over, and {} VMs were deleted in the finalizer.'. format(final_vm_size, final_vm_size - len(vms_to_cleanup))) logger.info( 'The following VMs were left over after the test: {}'.format( vms_to_cleanup)) quantifiers['VMs_To_Delete_In_Finalizer'] = final_vm_size quantifiers['VMs_Deleted_In_Finalizer'] = final_vm_size - len( vms_to_cleanup) quantifiers['Leftover_VMs'] = vms_to_cleanup add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info( 'Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, vm_name, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_provisioning}) prov = get_crud(scenario['providers'][0]) prov.create_rest() logger.info('Sleeping for Refresh: {}s'.format( scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) guid_list = prov.get_template_guids(scenario['templates']) guid_cycle = cycle(guid_list) cleanup_size = scenario['cleanup_size'] number_of_vms = scenario['number_of_vms'] total_time = scenario['total_time'] time_between_provision = scenario['time_between_provision'] total_provisioned_vms = 0 total_deleted_vms = 0 provisioned_vms = 0 starttime = time.time() while ((time.time() - starttime) < total_time): start_iteration_time = time.time() provision_list = [] for i in range(number_of_vms): total_provisioned_vms += 1 provisioned_vms += 1 vm_to_provision = 'test-{}-prov-{}'.format( test_ts, str(total_provisioned_vms).zfill(4)) guid_to_provision, provider_name = next(guid_cycle) provision_order.append((vm_to_provision, provider_name)) provision_list.append((vm_to_provision, guid_to_provision, prov.data['provisioning']['vlan'])) template = prov.data.templates.get('small_template') provision_data = get_provision_data(appliance.rest_api, prov, template.name) vm_name = provision_data["vm_fields"]["vm_name"] response = appliance.rest_api.collections.provision_requests.action.create( **provision_data) assert_response(appliance) provision_request = response[0] def _finished(): provision_request.reload() if "error" in provision_request.status.lower(): pytest.fail("Error when provisioning: `{}`".format( provision_request.message)) return provision_request.request_state.lower() in ("finished", "provisioned") wait_for(_finished, num_sec=800, delay=5, message="REST provisioning finishes") vm = appliance.rest_api.collections.vms.get(name=vm_name) creation_time = time.time() provision_time = round(creation_time - start_iteration_time, 2) logger.debug( 'Time to initiate provisioning: {}'.format(provision_time)) logger.info('{} VMs provisioned so far'.format(total_provisioned_vms)) if provisioned_vms > cleanup_size * len(scenario['providers']): start_remove_time = time.time() if appliance.rest_api.collections.vms.action.delete(vm): provision_order.pop(0) provisioned_vms -= 1 total_deleted_vms += 1 deletion_time = round(time.time() - start_remove_time, 2) logger.debug('Time to initate deleting: {}'.format(deletion_time)) logger.info('{} VMs deleted so far'.format(total_deleted_vms)) end_iteration_time = time.time() iteration_time = round(end_iteration_time - start_iteration_time, 2) elapsed_time = end_iteration_time - starttime logger.debug('Time to initiate provisioning and deletion: {}'.format( iteration_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if iteration_time < time_between_provision: wait_diff = time_between_provision - iteration_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_provision): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn( 'Time to initiate provisioning ({}) exceeded time between ' '({})'.format(iteration_time, time_between_provision)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Provisionings'] = total_provisioned_vms quantifiers['Deleted_VMs'] = total_deleted_vms logger.info( 'Provisioned {} VMs and deleted {} VMs during the scenario.'.format( total_provisioned_vms, total_deleted_vms)) logger.info('Test Ending...')
def test_refresh_providers(appliance, request, scenario): """ Refreshes providers then waits for a specific amount of time. Memory Monitor creates graphs and summary at the end of the scenario. """ from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = { 'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-refresh-providers', 'test_name': 'Refresh Providers', 'appliance_roles': ', '.join(roles_refresh_providers), 'scenario': scenario } monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info( 'Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles( {role: True for role in roles_refresh_providers}) for prov in scenario['providers']: get_crud(prov).create_rest() # Variable amount of time for refresh workload total_time = scenario['total_time'] starttime = time.time() time_between_refresh = scenario['time_between_refresh'] total_refreshed_providers = 0 while ((time.time() - starttime) < total_time): start_refresh_time = time.time() appliance.rest_api.collections.providers.reload() for prov in appliance.rest_api.collections.providers.all: prov.action.reload() total_refreshed_providers += 1 iteration_time = time.time() refresh_time = round(iteration_time - start_refresh_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue Refreshes: {}'.format(refresh_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if refresh_time < time_between_refresh: wait_diff = time_between_refresh - refresh_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_refresh): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn('Time to Queue Refreshes ({}) exceeded time between ' '({})'.format(refresh_time, time_between_refresh)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_Provider_Refreshes'] = total_refreshed_providers logger.info('Test Ending...')
def main(trackerbot_url, mark_usable=None, selected_provider=None): api = trackerbot.api(trackerbot_url) thread_q = [] thread_lock = Lock() template_providers = defaultdict(list) all_providers = (set(list_provider_keys()) if not selected_provider else set(selected_provider)) unresponsive_providers = set() # Queue up list_template calls for provider_key in all_providers: ipaddress = cfme_data.management_systems[provider_key].get('ipaddress') if ipaddress and not net.is_pingable(ipaddress): continue thread = Thread(target=get_provider_templates, args=(provider_key, template_providers, unresponsive_providers, thread_lock)) thread_q.append(thread) thread.start() # Join the queued calls for thread in thread_q: thread.join() seen_templates = set() if mark_usable is None: usable = {} else: usable = {'usable': mark_usable} existing_provider_templates = [ pt['id'] for pt in trackerbot.depaginate(api, api.providertemplate.get())['objects']] # Find some templates and update the API for template_name, providers in template_providers.items(): template_name = str(template_name) template_info = TemplateName.parse_template(template_name) # it turned out that some providers like ec2 may have templates w/o names. # this is easy protection against such issue. if not template_name.strip(): logger.warn('Ignoring template w/o name on provider %s', provider_key) continue # Don't want sprout templates if template_info.group_name in ('sprout', 'rhevm-internal'): logger.info('Ignoring %s from group %s', template_name, template_info.group_name) continue seen_templates.add(template_name) group = trackerbot.Group(template_info.group_name, stream=template_info.stream) try: template = trackerbot.Template(template_name, group, template_info.datestamp) except ValueError: logger.exception('Failure parsing provider %s template: %s', provider_key, template_name) continue for provider_key in providers: provider = trackerbot.Provider(provider_key) if '{}_{}'.format(template_name, provider_key) in existing_provider_templates: logger.info('Template %s already tracked for provider %s', template_name, provider_key) continue try: trackerbot.mark_provider_template(api, provider, template, **usable) logger.info('Added %s template %s on provider %s (datestamp: %s)', template_info.group_name, template_name, provider_key, template_info.datestamp) except SlumberHttpBaseException: logger.exception('%s: exception marking template %s', provider, template) # Remove provider relationships where they no longer exist, skipping unresponsive providers, # and providers not known to this environment for pt in trackerbot.depaginate(api, api.providertemplate.get())['objects']: key, template_name = pt['provider']['key'], pt['template']['name'] if key not in template_providers[template_name] and key not in unresponsive_providers: if key in all_providers: logger.info("Cleaning up template %s on %s", template_name, key) trackerbot.delete_provider_template(api, key, template_name) else: logger.info("Skipping template cleanup %s on unknown provider %s", template_name, key) # Remove templates that aren't on any providers anymore for template in trackerbot.depaginate(api, api.template.get())['objects']: if not template['providers'] and template['name'].strip(): logger.info("Deleting template %s (no providers)", template['name']) api.template(template['name']).delete()
def main(trackerbot_url, mark_usable=None, selected_provider=None): api = trackerbot.api(trackerbot_url) thread_q = [] thread_lock = Lock() template_providers = defaultdict(list) all_providers = (set(list_provider_keys()) if not selected_provider else set(selected_provider)) unresponsive_providers = set() # Queue up list_template calls for provider_key in all_providers: ipaddress = cfme_data.management_systems[provider_key].get('ipaddress') if ipaddress and not net.is_pingable(ipaddress): continue thread = Thread(target=get_provider_templates, args=(provider_key, template_providers, unresponsive_providers, thread_lock)) thread_q.append(thread) thread.start() # Join the queued calls for thread in thread_q: thread.join() seen_templates = set() if mark_usable is None: usable = {} else: usable = {'usable': mark_usable} existing_provider_templates = [ pt['id'] for pt in trackerbot.depaginate( api, api.providertemplate.get())['objects'] ] # Find some templates and update the API for template_name, providers in template_providers.items(): template_name = str(template_name) template_info = TemplateName.parse_template(template_name) # it turned out that some providers like ec2 may have templates w/o names. # this is easy protection against such issue. if not template_name.strip(): logger.warn('Ignoring template w/o name on provider %s', provider_key) continue # Don't want sprout templates if template_info.group_name in ('sprout', 'rhevm-internal'): logger.info('Ignoring %s from group %s', template_name, template_info.group_name) continue seen_templates.add(template_name) group = trackerbot.Group(template_info.group_name, stream=template_info.stream) try: template = trackerbot.Template(template_name, group, template_info.datestamp) except ValueError: logger.exception('Failure parsing provider %s template: %s', provider_key, template_name) continue for provider_key in providers: provider = trackerbot.Provider(provider_key) if '{}_{}'.format(template_name, provider_key) in existing_provider_templates: logger.info('Template %s already tracked for provider %s', template_name, provider_key) continue try: trackerbot.mark_provider_template(api, provider, template, **usable) logger.info( 'Added %s template %s on provider %s (datestamp: %s)', template_info.group_name, template_name, provider_key, template_info.datestamp) except SlumberHttpBaseException: logger.exception('%s: exception marking template %s', provider, template) # Remove provider relationships where they no longer exist, skipping unresponsive providers, # and providers not known to this environment for pt in trackerbot.depaginate(api, api.providertemplate.get())['objects']: key, template_name = pt['provider']['key'], pt['template']['name'] if key not in template_providers[ template_name] and key not in unresponsive_providers: if key in all_providers: logger.info("Cleaning up template %s on %s", template_name, key) trackerbot.delete_provider_template(api, key, template_name) else: logger.info( "Skipping template cleanup %s on unknown provider %s", template_name, key) # Remove templates that aren't on any providers anymore for template in trackerbot.depaginate(api, api.template.get())['objects']: if not template['providers'] and template['name'].strip(): logger.info("Deleting template %s (no providers)", template['name']) api.template(template['name']).delete()
def test_refresh_vms(appliance, request, scenario): """Refreshes all vm's then waits for a specific amount of time. Memory Monitor creates graphs and summary at the end of the scenario. Polarion: assignee: rhcf3_machine casecomponent: Appliance initialEstimate: 1/4h """ from_ts = int(time.time() * 1000) logger.debug('Scenario: {}'.format(scenario['name'])) appliance.clean_appliance() quantifiers = {} scenario_data = {'appliance_ip': appliance.hostname, 'appliance_name': cfme_performance['appliance']['appliance_name'], 'test_dir': 'workload-refresh-vm', 'test_name': 'Refresh VMs', 'appliance_roles': ', '.join(roles_refresh_vms), 'scenario': scenario} monitor_thread = SmemMemoryMonitor(appliance.ssh_client(), scenario_data) def cleanup_workload(scenario, from_ts, quantifiers, scenario_data): starttime = time.time() to_ts = int(starttime * 1000) g_urls = get_scenario_dashboard_urls(scenario, from_ts, to_ts) logger.debug('Started cleaning up monitoring thread.') monitor_thread.grafana_urls = g_urls monitor_thread.signal = False monitor_thread.join() add_workload_quantifiers(quantifiers, scenario_data) timediff = time.time() - starttime logger.info('Finished cleaning up monitoring thread in {}'.format(timediff)) request.addfinalizer(lambda: cleanup_workload(scenario, from_ts, quantifiers, scenario_data)) monitor_thread.start() appliance.wait_for_miq_server_workers_started(poll_interval=2) appliance.update_server_roles({role: True for role in roles_refresh_vms}) for prov in scenario['providers']: get_crud(prov).create_rest() logger.info('Sleeping for refresh: {}s'.format(scenario['refresh_sleep_time'])) time.sleep(scenario['refresh_sleep_time']) full_refresh_threshold_set = False if 'full_refresh_threshold' in scenario: if scenario['full_refresh_threshold'] != FULL_REFRESH_THRESHOLD_DEFAULT: appliance.set_full_refresh_threshold(scenario['full_refresh_threshold']) full_refresh_threshold_set = True if not full_refresh_threshold_set: logger.debug('Keeping full_refresh_threshold at default ({}).'.format( FULL_REFRESH_THRESHOLD_DEFAULT)) refresh_size = scenario['refresh_size'] vms = appliance.rest_api.collections.vms.all vms_iter = cycle(vms) logger.debug('Number of VM IDs: {}'.format(len(vms))) # Variable amount of time for refresh workload total_time = scenario['total_time'] starttime = time.time() time_between_refresh = scenario['time_between_refresh'] total_refreshed_vms = 0 while ((time.time() - starttime) < total_time): start_refresh_time = time.time() refresh_list = [next(vms_iter) for x in range(refresh_size)] for vm in refresh_list: vm.action.reload() total_refreshed_vms += len(refresh_list) iteration_time = time.time() refresh_time = round(iteration_time - start_refresh_time, 2) elapsed_time = iteration_time - starttime logger.debug('Time to Queue VM Refreshes: {}'.format(refresh_time)) logger.info('Time elapsed: {}/{}'.format(round(elapsed_time, 2), total_time)) if refresh_time < time_between_refresh: wait_diff = time_between_refresh - refresh_time time_remaining = total_time - elapsed_time if (time_remaining > 0 and time_remaining < time_between_refresh): time.sleep(time_remaining) elif time_remaining > 0: time.sleep(wait_diff) else: logger.warn('Time to Queue VM Refreshes ({}) exceeded time between ' '({})'.format(refresh_time, time_between_refresh)) quantifiers['Elapsed_Time'] = round(time.time() - starttime, 2) quantifiers['Queued_VM_Refreshes'] = total_refreshed_vms logger.info('Test Ending...')
def create(self, vm_name, provider, form_values=None, cancel=False, check_existing=False, find_in_cfme=False, wait=True): """Provisions an vm/instance with the given properties through CFME Args: vm_name: the vm/instance's name provider: provider object form_values: dictionary of form values for provisioning, structured into tabs cancel: boolean, whether or not to cancel form filling check_existing: verify if such vm_name exists find_in_cfme: verify that vm was created and appeared in CFME wait: wait for vm provision request end Note: Calling create on a sub-class of instance will generate the properly formatted dictionary when the correct fields are supplied. """ vm = self.instantiate(vm_name, provider) if check_existing and vm.exists: return vm if not provider.is_refreshed(): provider.refresh_provider_relationships() wait_for(provider.is_refreshed, func_kwargs={'refresh_delta': 10}, timeout=600) if not form_values: form_values = vm.vm_default_args else: inst_args = vm.vm_default_args form_values = recursive_update(inst_args, form_values) env = form_values.get('environment') or {} if env.get('automatic_placement'): form_values['environment'] = {'automatic_placement': True} form_values.update({'provider_name': provider.name}) if not form_values.get('template_name'): template_name = ( provider.data.get('provisioning').get('image', {}).get('name') or provider.data.get('provisioning').get('template')) vm.template_name = template_name form_values.update({'template_name': template_name}) view = navigate_to(self, 'Provision') view.form.fill(form_values) if cancel: view.form.cancel_button.click() view = self.browser.create_view(BaseLoggedInPage) view.flash.assert_success_message(self.ENTITY.PROVISION_CANCEL) view.flash.assert_no_error() else: view.form.submit_button.click() view = vm.appliance.browser.create_view(RequestsView) wait_for(lambda: view.flash.messages, fail_condition=[], timeout=10, delay=2, message='wait for Flash Success') view.flash.assert_no_error() if wait: request_description = 'Provision from [{}] to [{}]'.format( form_values.get('template_name'), vm.name) provision_request = vm.appliance.collections.requests.instantiate( request_description) logger.info('Waiting for cfme provision request for vm %s', vm.name) provision_request.wait_for_request(method='ui', num_sec=900) if provision_request.is_succeeded(method='ui'): logger.info('Waiting for vm %s to appear on provider %s', vm.name, provider.key) wait_for(provider.mgmt.does_vm_exist, [vm.name], handle_exception=True, num_sec=600) else: logger.warn( "Provisioning failed with the message {}".format( provision_request.row.last_message.text)) return None if find_in_cfme: vm.wait_to_appear(timeout=800) return vm