def test_tvault_rbac_nonadmin_ableto(self): try: # Use non-admin credentials os.environ['OS_USERNAME'] = CONF.identity.nonadmin_user os.environ['OS_PASSWORD'] = CONF.identity.nonadmin_password self.instances_id = [] # Create volume, Launch an Instance self.volumes_id = self.create_volume(volume_cleanup=False) LOG.debug("Volume-1 ID: " + str(self.volumes_id)) self.instances_id.append(self.create_vm(vm_cleanup=False)) LOG.debug("VM-1 ID: " + str(self.instances_id[0])) self.attach_volume(self.volumes_id, self.instances_id[0]) LOG.debug("Volume attached") # Create workload self.wid = self.workload_create( self.instances_id, tvaultconf.parallel, workload_name=tvaultconf.workload_name) LOG.debug("Workload ID: " + str(self.wid)) workload_available = self.wait_for_workload_tobe_available( self.wid) if workload_available == True: LOG.debug("Workload created successfully") reporting.add_test_step("Verification of workload creation", tvaultconf.PASS) reporting.set_test_script_status(tvaultconf.PASS) else: LOG.debug("workload creation unsuccessful") reporting.add_test_step("Verification of workload creation", tvaultconf.FAIL) raise Exception( "RBAC policy fails for workload creation by non-admin user" ) # Create full snapshot self.snapshot_id = self.workload_snapshot(self.wid, True) LOG.debug("Snapshot ID-1: " + str(self.snapshot_id)) #Wait till snapshot is complete snapshot_status = self.wait_for_snapshot_tobe_available( self.wid, self.snapshot_id) if snapshot_status == "available": LOG.debug("snapshot created successfully") reporting.add_test_step("Verification of snapshot creation", tvaultconf.PASS) reporting.set_test_script_status(tvaultconf.PASS) else: LOG.debug("snapshot creation unsuccessful") reporting.add_test_step("Verification of snapshot creation", tvaultconf.FAIL) raise Exception( "RBAC policy fails for snapshot creation by non-admin user" ) #Delete the original instance self.delete_vm(self.instances_id[0]) LOG.debug("Instance deleted successfully") #Delete corresponding volume self.delete_volume(self.volumes_id) LOG.debug("Volume deleted successfully") #Create one-click restore restore_status = "" restore_name = "restore_1" restore_id = self.snapshot_restore(self.wid, self.snapshot_id, restore_name=restore_name) restore_status = query_data.get_snapshot_restore_status( restore_name, self.snapshot_id) LOG.debug("Snapshot restore status initial: " + str(restore_status)) while (str(restore_status) != "available" and str(restore_status) != "error"): time.sleep(10) restore_status = query_data.get_snapshot_restore_status( restore_name, self.snapshot_id) LOG.debug("Snapshot restore status: " + str(restore_status)) if (str(restore_status) == "available"): LOG.debug("Snapshot Restore successfully completed") reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.PASS) else: LOG.debug("Snapshot Restore unsuccessful") reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.FAIL) # Launch recovery instance and Mount snapshot self.recoveryinstances_id = self.create_vm( flavor_id=CONF.compute.flavor_ref_alt, image_id=CONF.compute.fvm_image_ref) LOG.debug("VM-2 ID: " + str(self.recoveryinstances_id)) status = self.mount_snapshot(self.wid, self.snapshot_id, self.recoveryinstances_id) if status == True: LOG.debug("snapshot Mounted successfully") reporting.add_test_step("Verification of snapshot mount", tvaultconf.PASS) else: LOG.debug("snapshot Mount unsuccessful") reporting.add_test_step("Verification of snapshot mount", tvaultconf.FAIL) raise Exception("snapshot does not Mount by non-admin user") # Run Filesearch vmid_to_search = self.instances_id[0] filepath_to_search = "/File_1.txt" filecount_in_snapshots = {self.snapshot_id: 0} filesearch_id = self.filepath_search(vmid_to_search, filepath_to_search) snapshot_wise_filecount = self.verifyFilepath_Search( filesearch_id, filepath_to_search) for snapshot_id in filecount_in_snapshots.keys(): if snapshot_wise_filecount[ snapshot_id] == filecount_in_snapshots[snapshot_id]: filesearch_status = True else: filesearch_status = False LOG.debug("Filepath Search unsuccessful") reporting.add_test_step("Verification of Filepath serach", tvaultconf.FAIL) raise Exception( "Filesearch path does not execute correctly by non-admin user" ) if filesearch_status == True: LOG.debug("Filepath_Search successful") reporting.add_test_step("Verification of Filepath serach", tvaultconf.PASS) reporting.set_test_script_status(tvaultconf.PASS) reporting.test_case_to_write() except Exception as e: LOG.error("Exception: " + str(e)) reporting.set_test_script_status(tvaultconf.FAIL) reporting.test_case_to_write()
def test_1_image_volume(self): try: global volumes deleted = 0 reporting.add_test_script(str(__name__)) ## VM and Workload ### mount_points = ["mount_data_a", "mount_data_b"] md5sums_dir_before = {} LOG.debug("******************") kp = self.create_key_pair(tvaultconf.key_pair_name, keypair_cleanup=True) LOG.debug("Key_pair : " + str(kp)) vm_id = self.create_vm(key_pair=kp, vm_cleanup=False) LOG.debug("VM ID : " + str(vm_id)) volume_id = self.create_volume(volume_cleanup=False) LOG.debug("Volume ID: " + str(volume_id)) volumes = tvaultconf.volumes_parts self.attach_volume(volume_id, vm_id, attach_cleanup=False) LOG.debug("Volume attached") floating_ip_1 = self.assign_floating_ips(vm_id, False) LOG.debug("Assigned floating IP : " + str(floating_ip_1)) LOG.debug("Sleeping for 40 sec") time.sleep(40) self.data_ops(floating_ip_1, mount_points[0], 3) LOG.debug("Created disk and mounted the attached volume") md5sums_dir_before = self.calcmd5sum(floating_ip_1, mount_points[0]) LOG.debug("MD5sums for directory on original vm : " + str(md5sums_dir_before)) workload_create = command_argument_string.workload_create + " --instance instance-id=" + str( vm_id) rc = cli_parser.cli_returncode(workload_create) if rc != 0: reporting.add_test_step("Execute workload-create command", tvaultconf.FAIL) raise Exception( "Workload-create command did not execute correctly") else: reporting.add_test_step("Execute workload-create command", tvaultconf.PASS) LOG.debug("Workload-create command executed correctly") time.sleep(10) workload_id = query_data.get_workload_id(tvaultconf.workload_name) LOG.debug("Workload ID: " + str(workload_id)) if (workload_id != None): self.wait_for_workload_tobe_available(workload_id) if (self.getWorkloadStatus(workload_id) == "available"): reporting.add_test_step("Create workload", tvaultconf.PASS) else: reporting.add_test_step("Create workload", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) else: reporting.add_test_step("Create workload", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) if (tvaultconf.cleanup == True): self.addCleanup(self.workload_delete, workload_id) ### Full snapshot ### self.created = False #Create snapshot with CLI command create_snapshot = command_argument_string.snapshot_create + workload_id LOG.debug("Create snapshot command: " + str(create_snapshot)) rc = cli_parser.cli_returncode(create_snapshot) if rc != 0: reporting.add_test_step( "Execute workload-snapshot command with --full", tvaultconf.FAIL) raise Exception( "Command did not execute correctly for full snapshot") else: reporting.add_test_step( "Execute workload-snapshot command with --full", tvaultconf.PASS) LOG.debug("Command executed correctly for full snapshot") snapshot_id = query_data.get_inprogress_snapshot_id(workload_id) LOG.debug("Snapshot ID: " + str(snapshot_id)) wc = self.wait_for_snapshot_tobe_available(workload_id, snapshot_id) if (str(wc) == "available"): reporting.add_test_step("Full snapshot", tvaultconf.PASS) self.created = True else: if (str(wc) == "error"): pass if (self.created == False): reporting.add_test_step("Full snapshot", tvaultconf.FAIL) raise Exception("Workload snapshot did not get created") if (tvaultconf.cleanup == True): self.addCleanup(self.snapshot_delete, workload_id, snapshot_id) #Add some more data to files on VM ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1)) self.addCustomfilesOnLinuxVM(ssh, mount_points[0], 2) ssh.close() ### Incremental snapshot ### self.created = False #Create incremental snapshot using CLI command create_snapshot = command_argument_string.incr_snapshot_create + workload_id LOG.debug("Create snapshot command: " + str(create_snapshot)) rc = cli_parser.cli_returncode(create_snapshot) if rc != 0: reporting.add_test_step("Execute workload-snapshot command", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step("Execute workload-snapshot command", tvaultconf.PASS) LOG.debug("Command executed correctly") incr_snapshot_id = query_data.get_inprogress_snapshot_id( workload_id) LOG.debug("Incremental Snapshot ID: " + str(incr_snapshot_id)) #Wait for incremental snapshot to complete wc = self.wait_for_snapshot_tobe_available(workload_id, incr_snapshot_id) if (str(wc) == "available"): reporting.add_test_step("Incremental snapshot", tvaultconf.PASS) LOG.debug( "Workload incremental snapshot successfully completed") self.created = True if (self.created == False): reporting.add_test_step("Incremental snapshot", tvaultconf.FAIL) raise Exception( "Workload incremental snapshot did not get created") if (tvaultconf.cleanup == True): self.addCleanup(self.snapshot_delete, workload_id, incr_snapshot_id) ### Selective restore ### instance_details = [] network_details = [] restored_vm_details = [] vms_details_after_restore = [] temp_vdisks_data = [] int_net_1_name = self.get_net_name( CONF.network.internal_network_id) LOG.debug("int_net_1_name" + str(int_net_1_name)) int_net_1_subnets = self.get_subnet_id( CONF.network.internal_network_id) LOG.debug("int_net_1_subnet" + str(int_net_1_subnets)) temp_vdisks_data.append([{ 'id': volume_id, 'availability_zone': CONF.volume.volume_availability_zone, 'new_volume_type': CONF.volume.volume_type }]) LOG.debug("Vdisks details for restore" + str(temp_vdisks_data)) #Create instance details for restore.json vm_name = "tempest_test_vm_" + vm_id + "_restored" temp_instance_data = { 'id': vm_id, 'availability_zone': CONF.compute.vm_availability_zone, 'include': True, 'restore_boot_disk': True, 'name': vm_name, 'vdisks': temp_vdisks_data[0] } instance_details.append(temp_instance_data) LOG.debug("Instance details for restore: " + str(instance_details)) #Create network details for restore.json snapshot_network = { 'id': CONF.network.internal_network_id, 'subnet': { 'id': int_net_1_subnets } } target_network = { 'name': int_net_1_name, 'id': CONF.network.internal_network_id, 'subnet': { 'id': int_net_1_subnets } } network_details = [{ 'snapshot_network': snapshot_network, 'target_network': target_network }] LOG.debug("Network details for restore: " + str(network_details)) LOG.debug("Snapshot id : " + str(snapshot_id)) #Trigger selective restore restore_id_1 = self.snapshot_selective_restore( workload_id, snapshot_id, restore_name=tvaultconf.restore_name, restore_cleanup=True, instance_details=instance_details, network_details=network_details) self.wait_for_snapshot_tobe_available(workload_id, snapshot_id) if (self.getRestoreStatus(workload_id, snapshot_id, restore_id_1) == "available"): reporting.add_test_step("Selective restore", tvaultconf.PASS) else: reporting.add_test_step("Selective restore", tvaultconf.FAIL) raise Exception("Selective restore failed") #Fetch instance details after restore vm_list = self.get_restored_vm_list(restore_id_1) LOG.debug("Restored vm(selective) ID : " + str(vm_list)) time.sleep(40) floating_ip_2 = self.assign_floating_ips(vm_list[0], True) LOG.debug("Floating ip assigned to selective restore vm -> " + str(floating_ip_2)) md5sums_dir_after = {} ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_2)) self.execute_command_disk_mount(ssh, str(floating_ip_2), [volumes[0]], [mount_points[0]]) time.sleep(5) md5sums_dir_after = self.calcmd5sum(floating_ip_2, mount_points[0]) ssh.close() LOG.debug("md5sums_dir_before") LOG.debug(md5sums_dir_before[str(floating_ip_1)]) LOG.debug("md5sums_dir_after") LOG.debug(md5sums_dir_after[str(floating_ip_2)]) if md5sums_dir_before[str(floating_ip_1)] == md5sums_dir_after[str( floating_ip_2)]: LOG.debug("***MDSUMS MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS) else: LOG.debug("***MDSUMS DON'T MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) for id in range(len(vm_list)): restored_vm_details.append(self.get_vm_details(vm_list[id])) LOG.debug("Restored vm details list: " + str(restored_vm_details)) vms_details_after_restore = self.get_vms_details_list( restored_vm_details) LOG.debug("VM details after restore: " + str(vms_details_after_restore)) #Compare the data before and after restore for i in range(len(vms_details_after_restore)): if (vms_details_after_restore[i]['network_name'] == int_net_1_name): reporting.add_test_step( "Network verification for instance-" + str(i + 1), tvaultconf.PASS) else: LOG.error("Expected network: " + str(int_net_1_name)) LOG.error( "Restored network: " + str(vms_details_after_restore[i]['network_name'])) reporting.add_test_step( "Network verification for instance-" + str(i + 1), tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) ### In-place Restore ### #Create in-place restore with CLI command restore_command = command_argument_string.inplace_restore + str( tvaultconf.restore_filename) + " " + str(incr_snapshot_id) LOG.debug("inplace restore cli command: " + str(restore_command)) restore_json = json.dumps({ 'openstack': { 'instances': [{ 'restore_boot_disk': True, 'include': True, 'id': vm_id, 'vdisks': [{ 'restore_cinder_volume': True, 'id': volume_id, 'new_volume_type': CONF.volume.volume_type }], }], 'networks_mapping': { 'networks': [] } }, 'restore_type': 'inplace', 'type': 'openstack' }) LOG.debug("restore.json for inplace restore: " + str(restore_json)) #Create Restore.json with open(tvaultconf.restore_filename, 'w') as f: f.write(str(json.loads(restore_json))) rc = cli_parser.cli_returncode(restore_command) if rc != 0: reporting.add_test_step("Triggering In-Place restore via CLI", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step("Triggering In-Place restore via CLI", tvaultconf.PASS) LOG.debug("Command executed correctly") #get restore id from database restore_id_2 = query_data.get_snapshot_restore_id(incr_snapshot_id) self.wait_for_snapshot_tobe_available(workload_id, incr_snapshot_id) #get in-place restore status if (self.getRestoreStatus(workload_id, incr_snapshot_id, restore_id_2) == "available"): reporting.add_test_step("In-place restore", tvaultconf.PASS) else: reporting.add_test_step("In-place restore", tvaultconf.FAIL) raise Exception("In-place restore failed") #Fetch instance details after restore vm_list = self.get_restored_vm_list(restore_id_2) LOG.debug("Restored vm(In-place) ID : " + str(vm_list)) time.sleep(40) md5sums_dir_after = {} ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1)) self.execute_command_disk_mount(ssh, str(floating_ip_1), [volumes[0]], [mount_points[0]]) time.sleep(5) md5sums_dir_after = self.calcmd5sum(floating_ip_1, mount_points[0]) ssh.close() LOG.debug("<----md5sums_dir_before---->") LOG.debug(md5sums_dir_before[str(floating_ip_1)]) LOG.debug("<----md5sums_dir_after---->") LOG.debug(md5sums_dir_after[str(floating_ip_1)]) if md5sums_dir_before[str(floating_ip_1)] == md5sums_dir_after[str( floating_ip_1)]: LOG.debug("***MDSUMS MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS) else: LOG.debug("***MDSUMS DON'T MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) if (tvaultconf.cleanup == True): self.addCleanup(self.restore_delete, workload_id, incr_snapshot_id, restore_id_2) LOG.debug("Snapshot Restore(in-place) deleted successfully") ### One-click restore ### mdb = self.calcmd5sum(floating_ip_1, mount_points[0]) LOG.debug( "MD5SUMS before deleting the instance for one click restore : " + str(mdb)) self.disassociate_floating_ip_from_server(floating_ip_1, vm_id) self.detach_volume(vm_id, volume_id) #Delete the original instance self.delete_vm(vm_id) LOG.debug( "Instance deleted successfully for one click restore : " + str(vm_id)) time.sleep(10) #Delete volume attached to original instance self.delete_volume(volume_id) LOG.debug("Volumes deleted successfully for one click restore : " + str(volume_id)) deleted = 1 #Create one-click restore using CLI command restore_command = command_argument_string.oneclick_restore + " " + snapshot_id rc = cli_parser.cli_returncode(restore_command) if rc != 0: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.PASS) LOG.debug("Command executed correctly") wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, snapshot_id) LOG.debug("Snapshot restore status: " + str(wc)) restore_id_3 = query_data.get_snapshot_restore_id(snapshot_id) LOG.debug("Restore ID: " + str(restore_id_3)) self.wait_for_snapshot_tobe_available(workload_id, snapshot_id) if (self.getRestoreStatus(workload_id, snapshot_id, restore_id_3) == "available"): reporting.add_test_step("One-click restore", tvaultconf.PASS) LOG.debug("One-click restore passed") else: reporting.add_test_step("One-click restore", tvaultconf.FAIL) LOG.debug("One-click restore failed") raise Exception("One-click restore failed") LOG.debug("One-click restore complete") #Fetch instance details after restore vm_list = self.get_restored_vm_list(restore_id_3) LOG.debug("Restored vms : " + str(vm_list)) mda = {} ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1)) self.execute_command_disk_mount(ssh, str(floating_ip_1), [volumes[0]], [mount_points[0]]) time.sleep(5) mda = self.calcmd5sum(floating_ip_1, mount_points[0]) LOG.debug( "MD5SUMS after deleting the instance for one click restore : " + str(mda)) ssh.close() if mdb[str(floating_ip_1)] == mda[str(floating_ip_1)]: LOG.debug("***MDSUMS MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS) else: LOG.debug("***MDSUMS DON'T MATCH***") reporting.add_test_step("Md5 Verification for volume", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) restored_volumes = self.get_restored_volume_list(restore_id_3) LOG.debug("Restored volumes : ") LOG.debug(restored_volumes) if (tvaultconf.cleanup == True): self.addCleanup(self.restore_delete, workload_id, snapshot_id, restore_id_3) self.addCleanup(self.delete_restored_vms, vm_list, restored_volumes) reporting.test_case_to_write() except Exception as e: LOG.error("Exception: " + str(e)) if (deleted == 0): self.disassociate_floating_ip_from_server(floating_ip_1, vm_id) self.detach_volume(vm_id, volume_id) self.delete_vm(vm_id) time.sleep(10) self.delete_volume(volume_id) reporting.set_test_script_status(tvaultconf.FAIL) reporting.test_case_to_write()
def test_tvault1037_list_restore(self): try: # Prerequisites self.created = False self.workload_instances = [] # Launch instance self.vm_id = self.create_vm() LOG.debug("VM ID: " + str(self.vm_id)) # Create volume self.volume_id = self.create_volume() LOG.debug("Volume ID: " + str(self.volume_id)) # Attach volume to the instance self.attach_volume(self.volume_id, self.vm_id) LOG.debug("Volume attached") # Create workload self.workload_instances.append(self.vm_id) self.wid = self.workload_create( self.workload_instances, tvaultconf.parallel, workload_name=tvaultconf.workload_name) LOG.debug("Workload ID: " + str(self.wid)) time.sleep(5) # Create snapshot self.snapshot_id = self.workload_snapshot(self.wid, True, tvaultconf.snapshot_name) LOG.debug("Snapshot ID: " + str(self.snapshot_id)) self.wait_for_snapshot_tobe_available(self.wid, self.snapshot_id) # Delete instance self.delete_vm(self.vm_id) LOG.debug("Instance deleted successfully") # Delete corresponding volume self.delete_volume(self.volume_id) LOG.debug("Volume deleted successfully") # Create one-click restore self.restore_id = self.snapshot_restore(self.wid, self.snapshot_id, tvaultconf.restore_name) LOG.debug("Restore ID: " + str(self.restore_id)) # Wait till restore is complete wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_id) LOG.debug("Snapshot restore status: " + str(wc)) while (str(wc) != "available" or str(wc) != "error"): time.sleep(5) wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_id) LOG.debug("Snapshot restore status: " + str(wc)) if (str(wc) == "available"): LOG.debug("Snapshot Restore successfully completed") self.created = True break else: if (str(wc) == "error"): break if (self.created == False): reporting.add_test_step("One click Restore", tvaultconf.FAIL) raise Exception("Snapshot Restore did not get created") # List Restores using CLI command rc = cli_parser.cli_returncode( command_argument_string.restore_list) if rc != 0: reporting.add_test_step("Execute restore-list command", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step("Execute restore-list command", tvaultconf.PASS) LOG.debug("Command executed correctly") wc = query_data.get_available_restores() out = cli_parser.cli_output(command_argument_string.restore_list) if (int(wc) == int(out)): reporting.add_test_step("Verification with DB", tvaultconf.PASS) LOG.debug( "Restore list command listed available restores correctly") else: reporting.add_test_step("Verification with DB", tvaultconf.FAIL) raise Exception( "Restore list command did not list available restores correctly" ) reporting.test_case_to_write() except Exception as e: LOG.error("Exception: " + str(e)) reporting.set_test_script_status(tvaultconf.FAIL) reporting.test_case_to_write()
def test_6_regression(self): reporting.add_test_script( str(__name__) + "_one_click_restore_bootfrom_image") try: if self.exception != "": LOG.debug("pre req failed") reporting.add_test_step(str(self.exception), tvaultconf.FAIL) raise Exception(str(self.exception)) LOG.debug("pre req completed") self.created = False #Delete the original instance self.delete_vms(self.workload_instances) self.delete_key_pair(tvaultconf.key_pair_name) self.delete_security_group(self.security_group_id) self.delete_flavor(self.flavor_id) LOG.debug("Instances deleted successfully") #Create one-click restore using CLI command restore_command = command_argument_string.oneclick_restore + " " + self.snapshot_ids[ 1] rc = cli_parser.cli_returncode(restore_command) if rc != 0: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.PASS) LOG.debug("Command executed correctly") wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_ids[1]) LOG.debug("Snapshot restore status: " + str(wc)) while (str(wc) != "available" or str(wc) != "error"): time.sleep(5) wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_ids[1]) LOG.debug("Snapshot restore status: " + str(wc)) if (str(wc) == "available"): LOG.debug("Snapshot Restore successfully completed") reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.PASS) self.created = True break else: if (str(wc) == "error"): break if (self.created == False): reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.FAIL) raise Exception("Snapshot Restore did not get created") self.restore_id = query_data.get_snapshot_restore_id( self.snapshot_id) LOG.debug("Restore ID: " + str(self.restore_id)) #Fetch instance details after restore self.restored_vm_details_list = [] #restored vms list self.vm_list = self.get_restored_vm_list(self.restore_id) LOG.debug("Restored vms : " + str(self.vm_list)) #restored vms all details list for id in range(len(self.workload_instances)): self.restored_vm_details_list.append( self.get_vm_details(self.vm_list[id])) LOG.debug("Restored vm details list: " + str(self.restored_vm_details_list)) #required details of restored vms self.vms_details_after_restore = self.get_vms_details_list( self.restored_vm_details_list) LOG.debug("VM details after restore: " + str(self.vms_details_after_restore)) #Verify floating ips self.floating_ips_after_restore = [] for i in range(len(self.vms_details_after_restore)): self.floating_ips_after_restore.append( self.vms_details_after_restore[i]['floating_ip']) if (self.floating_ips_after_restore.sort() == self.floating_ips_list.sort()): reporting.add_test_step("Floating ip verification", tvaultconf.PASS) else: LOG.error("Floating ips before restore: " + str(self.floating_ips_list.sort())) LOG.error("Floating ips after restore: " + str(self.floating_ips_after_restore.sort())) reporting.add_test_step("Floating ip verification", tvaultconf.FAIL) reporting.set_test_script_status(tvaultconf.FAIL) #calculate md5sum after restore tree = lambda: collections.defaultdict(tree) md5_sum_after_oneclick_restore = tree() for floating_ip in self.floating_ips_list: for mount_point in mount_points: ssh = self.SshRemoteMachineConnectionWithRSAKey( str(floating_ip)) md5_sum_after_oneclick_restore[str(floating_ip)][str( mount_point)] = self.calculatemmd5checksum( ssh, mount_point) ssh.close() LOG.debug("md5_sum_after_oneclick_restore" + str(md5_sum_after_oneclick_restore)) #md5sum verification if (self.md5sums_dir_before == md5_sum_after_oneclick_restore): reporting.add_test_step("Md5 Verification", tvaultconf.PASS) else: reporting.set_test_script_status(tvaultconf.FAIL) reporting.add_test_step("Md5 Verification", tvaultconf.FAIL) reporting.test_case_to_write() except Exception as e: LOG.error("Exception: " + str(e)) reporting.set_test_script_status(tvaultconf.FAIL) reporting.test_case_to_write()
def test_tvault1040_oneclick_restore(self): try: #Prerequisites self.created = False self.workload_instances = [] #Launch instance self.vm_id = self.create_vm(vm_cleanup=False) LOG.debug("VM ID: " + str(self.vm_id)) #Create volume self.volume_id = self.create_volume(volume_cleanup=False) LOG.debug("Volume ID: " + str(self.volume_id)) #Attach volume to the instance self.attach_volume(self.volume_id, self.vm_id, attach_cleanup=False) LOG.debug("Volume attached") #Create workload self.workload_instances.append(self.vm_id) self.wid = self.workload_create( self.workload_instances, tvaultconf.parallel, workload_name=tvaultconf.workload_name) LOG.debug("Workload ID: " + str(self.wid)) time.sleep(5) #Create snapshot self.snapshot_id = self.workload_snapshot(self.wid, True, tvaultconf.snapshot_name) LOG.debug("Snapshot ID: " + str(self.snapshot_id)) #Wait till snapshot is complete self.wait_for_snapshot_tobe_available(self.wid, self.snapshot_id) #Delete the original instance self.delete_vm(self.vm_id) LOG.debug("Instance deleted successfully") #Delete corresponding volume self.delete_volume(self.volume_id) LOG.debug("Volume deleted successfully") #Create one-click restore using CLI command restore_command = command_argument_string.oneclick_restore + " " + self.snapshot_id rc = cli_parser.cli_returncode(restore_command) if rc != 0: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.FAIL) raise Exception("Command did not execute correctly") else: reporting.add_test_step( "Execute snapshot-oneclick-restore command", tvaultconf.PASS) LOG.debug("Command executed correctly") wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_id) LOG.debug("Snapshot restore status: " + str(wc)) while (str(wc) != "available" or str(wc) != "error"): time.sleep(5) wc = query_data.get_snapshot_restore_status( tvaultconf.restore_name, self.snapshot_id) LOG.debug("Snapshot restore status: " + str(wc)) if (str(wc) == "available"): LOG.debug("Snapshot Restore successfully completed") reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.PASS) self.created = True break else: if (str(wc) == "error"): break if (self.created == False): reporting.add_test_step( "Snapshot one-click restore verification with DB", tvaultconf.FAIL) raise Exception("Snapshot Restore did not get created") self.restore_id = query_data.get_snapshot_restore_id( self.snapshot_id) LOG.debug("Restore ID: " + str(self.restore_id)) #Cleanup #self.volume_snapshots = self.get_available_volume_snapshots() #self.delete_volume_snapshots(self.volume_snapshots) #Delete restore for snapshot self.restore_delete(self.wid, self.snapshot_id, self.restore_id) LOG.debug("Snapshot Restore deleted successfully") #Delete restored VM instance and volume #self.delete_restored_vms(self.restore_id) #LOG.debug("Restored VM and volume deleted successfully") reporting.test_case_to_write() except Exception as e: LOG.error("Exception: " + str(e)) reporting.set_test_script_status(tvaultconf.FAIL) reporting.test_case_to_write()