def test_network_restore(self):
try:
reporting.add_test_script(str(__name__))
self.delete_network_topology()
ntwrks = self.create_network()
vms = {}
nws = [x['id'] for x in ntwrks]
vmid = self.create_vm(vm_name="instance",
networkid=[{
'uuid': random.choice(nws)
}],
vm_cleanup=True)
nt_bf, sbnt_bf, rt_bf, intf_bf = self.get_topology_details()
workload_id = self.workload_create([vmid],
tvaultconf.parallel,
workload_cleanup=True)
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)
raise Exception("Workload creation failed")
snapshot_id = self.workload_snapshot(workload_id,
True,
snapshot_cleanup=True)
time.sleep(5)
self.wait_for_workload_tobe_available(workload_id)
if (self.getSnapshotStatus(workload_id,
snapshot_id) == "available"):
reporting.add_test_step("Create full snapshot",
tvaultconf.PASS)
LOG.debug("Full snapshot available!!")
else:
reporting.add_test_step("Create full snapshot",
tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
instance_details = []
vm_name = "restored_instance"
temp_instance_data = {
'id': vmid,
'include': True,
'restore_boot_disk': True,
'name': vm_name,
'vdisks': []
}
instance_details.append(temp_instance_data)
LOG.debug("Instance details for restore: " + str(instance_details))
self.delete_vm(vmid)
self.delete_network_topology()
restore_id = self.snapshot_selective_restore(
workload_id,
snapshot_id,
restore_name=tvaultconf.restore_name,
instance_details=instance_details,
network_restore_flag=True)
self.wait_for_snapshot_tobe_available(workload_id, snapshot_id)
if (self.getRestoreStatus(workload_id, snapshot_id,
restore_id) == "available"):
reporting.add_test_step(
"Selective restore with network restore", tvaultconf.PASS)
else:
reporting.add_test_step(
"Selective restore with network restore", tvaultconf.FAIL)
raise Exception(
"Selective restore with network restore failed")
nt_af, sbnt_af, rt_af, intf_af = self.get_topology_details()
if nt_bf == nt_af:
reporting.add_test_step(
"Verify network details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify network details after network restore",
tvaultconf.FAIL)
LOG.error(
"Network details before and after restore: %s , %s" %
nt_bf, nt_af)
if sbnt_bf == sbnt_af:
reporting.add_test_step(
"Verify subnet details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify subnet details after network restore",
tvaultconf.FAIL)
LOG.error(
"Subnet details before and after restore: %s , %s" %
sbnt_bf, sbnt_af)
if rt_bf == rt_af:
reporting.add_test_step(
"Verify router details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify router details after network restore",
tvaultconf.FAIL)
LOG.error(
"Router details before and after restore: %s , %s" % rt_bf,
rt_af)
if intf_bf == intf_af:
reporting.add_test_step(
"Verify interface details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify interface details after network restore",
tvaultconf.FAIL)
LOG.error(
"Interface details before and after restore: %s , %s" %
intf_bf, intf_af)
self.delete_vm(self.get_restored_vm_list(restore_id)[0])
self.delete_network_topology()
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_3_regression(self):
reporting.add_test_script(str(__name__) + "_inplace_restore_cli")
try:
LOG.debug("pre req completed")
volumes = tvaultconf.volumes_parts
mount_points = ["mount_data_b", "mount_data_c"]
#calculate md5 sum before
tree = lambda: collections.defaultdict(tree)
self.md5sums_dir_before = tree()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[0]))
self.md5sums_dir_before[str(self.floating_ips_list[0])][str(
mount_points[0])] = self.calculatemmd5checksum(
ssh, mount_points[0])
ssh.close()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[1]))
self.md5sums_dir_before[str(self.floating_ips_list[1])][str(
mount_points[0])] = self.calculatemmd5checksum(
ssh, mount_points[0])
self.md5sums_dir_before[str(self.floating_ips_list[1])][str(
mount_points[1])] = self.calculatemmd5checksum(
ssh, mount_points[1])
ssh.close()
LOG.debug("md5sums_dir_before" + str(self.md5sums_dir_before))
#Fill some data on each of the volumes attached
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[0]))
self.addCustomSizedfilesOnLinux(ssh, mount_points[0], 2)
ssh.close()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[1]))
self.addCustomSizedfilesOnLinux(ssh, mount_points[0], 2)
self.addCustomSizedfilesOnLinux(ssh, mount_points[1], 2)
ssh.close()
#Create in-place restore with CLI command
restore_command = command_argument_string.inplace_restore + str(
tvaultconf.restore_filename) + " " + str(self.incr_snapshot_id)
LOG.debug("inplace restore cli command: " + str(restore_command))
#Restore.json with only volume 2 excluded
restore_json = json.dumps({
'openstack': {
'instances': [{
'restore_boot_disk':
True,
'include':
True,
'id':
self.workload_instances[0],
'vdisks': [{
'restore_cinder_volume': True,
'id': self.volumes_list[0],
'new_volume_type': CONF.volume.volume_type
}]
}, {
'restore_boot_disk':
True,
'include':
True,
'id':
self.workload_instances[1],
'vdisks': [{
'restore_cinder_volme': True,
'id': self.volumes_list[1],
'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
self.restore_id = query_data.get_snapshot_restore_id(
self.incr_snapshot_id)
self.wait_for_snapshot_tobe_available(self.workload_id,
self.incr_snapshot_id)
#get in-place restore status
if (self.getRestoreStatus(self.workload_id, self.incr_snapshot_id,
self.restore_id) == "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")
# mount volumes after restore
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[0]))
self.execute_command_disk_mount(ssh,
str(self.floating_ips_list[0]),
[volumes[0]], [mount_points[0]])
ssh.close()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[1]))
self.execute_command_disk_mount(ssh,
str(self.floating_ips_list[1]),
volumes, mount_points)
ssh.close()
# calculate md5 after inplace restore
tree = lambda: collections.defaultdict(tree)
md5_sum_after_in_place_restore = tree()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[0]))
md5_sum_after_in_place_restore[str(self.floating_ips_list[0])][str(
mount_points[0])] = self.calculatemmd5checksum(
ssh, mount_points[0])
ssh.close()
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(self.floating_ips_list[1]))
md5_sum_after_in_place_restore[str(self.floating_ips_list[1])][str(
mount_points[0])] = self.calculatemmd5checksum(
ssh, mount_points[0])
md5_sum_after_in_place_restore[str(self.floating_ips_list[1])][str(
mount_points[1])] = self.calculatemmd5checksum(
ssh, mount_points[1])
ssh.close()
LOG.debug("md5_sum_after_in_place_restore" +
str(md5_sum_after_in_place_restore))
#md5 sum verification
if self.md5sums_dir_before[str(self.floating_ips_list[0])][str(
mount_points[0])] == md5_sum_after_in_place_restore[str(
self.floating_ips_list[0])][str(mount_points[0])]:
reporting.add_test_step("Md5 Verification for volume 1",
tvaultconf.PASS)
else:
reporting.add_test_step("Md5 Verification for volume 1",
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
if self.md5sums_dir_before[str(self.floating_ips_list[1])][str(
mount_points[0])] == md5_sum_after_in_place_restore[str(
self.floating_ips_list[1])][str(mount_points[0])]:
reporting.add_test_step("Md5 Verification for volume 2",
tvaultconf.PASS)
else:
reporting.add_test_step("Md5 Verification for volume 2",
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
if self.md5sums_dir_before[str(self.floating_ips_list[1])][str(
mount_points[1])] != md5_sum_after_in_place_restore[str(
self.floating_ips_list[1])][str(mount_points[1])]:
reporting.add_test_step("Md5 Verification for volume 3",
tvaultconf.PASS)
else:
reporting.add_test_step("Md5 Verification for volume 3",
tvaultconf.FAIL)
reporting.set_test_script_status(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()
finally:
#Delete restore for snapshot
self.restored_volumes = self.get_restored_volume_list(
self.restore_id)
if tvaultconf.cleanup == True:
self.restore_delete(self.workload_id, self.incr_snapshot_id,
self.restore_id)
LOG.debug("Snapshot Restore deleted successfully")
#Delete restored volumes and volume snapshots
self.delete_volumes(self.restored_volumes)
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_1_config_workload_configure(self):
reporting.add_test_script(str(__name__) + "_configure")
try:
# prerequisite handles config_user creation and config_backup_pvk(private key) creation
# for config backup configuration, yaml_file creation
self.create_config_backup_yaml()
# config backup configuration with CLI command
config_workload_command = command_argument_string.config_workload_configure + " --config-file yaml_file.yaml --authorized-key config_backup_pvk "
LOG.debug("config workload configure cli command: " +
str(config_workload_command))
rc = cli_parser.cli_returncode(config_workload_command)
if rc != 0:
reporting.add_test_step(
"Triggering config_workload_configure command via CLI",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Triggering config_workload_configure command via CLI",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
config_workload_output = self.get_config_workload()
LOG.debug("config_workload_show_command output: " +
str(config_workload_output))
for metadata in config_workload_output['metadata']:
if metadata['key'] == 'services_to_backup':
config_dirs = metadata['value']
found = False
for key in tvaultconf.config_yaml.keys():
if key in config_dirs:
found = True
if found:
LOG.debug("Config dirs existance: True")
reporting.add_test_step("Config dirs existance",
tvaultconf.PASS)
else:
LOG.debug("Config dirs existance: False")
reporting.add_test_step("Config dirs existance",
tvaultconf.FAIL)
config_workload_status = config_workload_output['status']
if config_workload_status == "available":
LOG.debug(
"config_workload status is available, config_workload_id: "
+ config_workload_output['id'])
reporting.add_test_step("config_workload status: available",
tvaultconf.PASS)
else:
LOG.debug(
"config_workload status is not available, Error msg: " +
config_workload_output['error_msg'])
reporting.add_test_step(
"config_workload status: " +
config_workload_output['status'], tvaultconf.FAIL)
raise Exception("Config Workload Configure Failed.")
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_tvault_rbac_backuprole_touser_policyjson(self):
try:
workload_create_error_str = "Policy doesn't allow workload:workload_create to be performed."
# Change policy.json file on tvault to change role and rule
self.change_policyjson_file("backup", "backup_api")
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")
# Use backupuser credentials
os.environ['OS_USERNAME'] = CONF.identity.backupuser
os.environ['OS_PASSWORD'] = CONF.identity.backupuser_password
# Create workload with CLI by backup role
workload_create = command_argument_string.workload_create + " --instance instance-id=" + str(
self.instances_id[0])
rc = cli_parser.cli_returncode(workload_create)
if rc != 0:
LOG.debug("workload creation unsuccessful by backup role")
raise Exception(
"RBAC policy fails for workload creation by backup role")
else:
LOG.debug("Workload created successfully by backup role")
reporting.add_test_step(
"Execute workload_create command by backup role",
tvaultconf.PASS)
time.sleep(10)
self.wid1 = query_data.get_workload_id(
tvaultconf.workload_name)
workload_available = self.wait_for_workload_tobe_available(
self.wid1)
# Run snapshot_create CLI by backup role
snapshot_create = command_argument_string.snapshot_create + str(
self.wid1)
LOG.debug("snapshot_create command: " + str(snapshot_create))
rc = cli_parser.cli_returncode(snapshot_create)
if rc != 0:
reporting.add_test_step(
"Execute snapshot_create command by backup role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_create did not execute correctly by backup role"
)
else:
reporting.add_test_step(
"Execute snapshot_create command by backup role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_create executed correctly by backup role"
)
self.snapshot_id1 = query_data.get_inprogress_snapshot_id(
self.wid1)
wc = self.wait_for_snapshot_tobe_available(
self.wid1, self.snapshot_id1)
#Delete the original instance
self.delete_vm(self.instances_id[0])
LOG.debug("Instance deleted successfully for restore")
#Delete corresponding volume
self.delete_volume(self.volumes_id)
LOG.debug("Volume deleted successfully for restore")
#Create one-click restore using CLI command by backup role
restore_command = command_argument_string.oneclick_restore + " " + str(
self.snapshot_id1)
rc = cli_parser.cli_returncode(restore_command)
if rc != 0:
reporting.add_test_step(
"Execute snapshot-oneclick-restore command by backup role",
tvaultconf.FAIL)
raise Exception(
"Command one-click restore did not execute correctly by backup role"
)
else:
reporting.add_test_step(
"Execute snapshot-oneclick-restore command by backup role",
tvaultconf.PASS)
LOG.debug(
"Command one-click restore executed correctly backup role")
wc = self.wait_for_snapshot_tobe_available(
self.wid1, self.snapshot_id1)
self.restore_id1 = query_data.get_snapshot_restore_id(
self.snapshot_id1)
LOG.debug("Restore ID: " + str(self.restore_id1))
self.restore_vm_id1 = self.get_restored_vm_list(
self.restore_id1)
LOG.debug("Restore VM ID: " + str(self.restore_vm_id1))
self.restore_volume_id1 = self.get_restored_volume_list(
self.restore_id1)
LOG.debug("Restore Volume ID: " + str(self.restore_volume_id1))
# Use admin credentials
os.environ['OS_USERNAME'] = CONF.identity.username
os.environ['OS_PASSWORD'] = CONF.identity.password
# Create workload with CLI by admin role
workload_create = command_argument_string.workload_create + " --instance instance-id=" + str(
self.restore_vm_id1)
error = cli_parser.cli_error(workload_create)
if error and (str(
error.strip('\n')).find(workload_create_error_str) != -1):
LOG.debug(
"Command workload_create did not execute correctly by admin role"
)
reporting.add_test_step(
"Can not execute workload_create command by admin role",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Command workload_create did not execute correctly by admin role",
tvaultconf.FAIL)
raise Exception(
"Command workload_create executed correctly by admin role")
# Run snapshot_create CLI by admin role
snapshot_create = command_argument_string.snapshot_create + str(
self.wid1)
LOG.debug("snapshot_create command: " + str(snapshot_create))
rc = cli_parser.cli_returncode(snapshot_create)
if rc != 0:
reporting.add_test_step(
"Can not execute snapshot_create command by admin role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_create did not execute correctly by admin role"
)
else:
reporting.add_test_step(
"Can not execute snapshot_create command by admin role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_create executed correctly by admin role")
#Create one-click restore using CLI command by admin role
restore_command = command_argument_string.oneclick_restore + " " + str(
self.snapshot_id1)
rc = cli_parser.cli_returncode(restore_command)
if rc != 0:
reporting.add_test_step(
"Can not execute restore_create command by admin role",
tvaultconf.PASS)
LOG.debug(
"Command restore_create did not execute correctly by admin role"
)
else:
reporting.add_test_step(
"Can not execute restore_create command by admin role",
tvaultconf.FAIL)
raise Exception(
"Command restore_create executed correctly by admin role")
# Run restore_delete CLI by admin role
restore_delete = command_argument_string.restore_delete + str(
self.restore_id1)
rc = cli_parser.cli_returncode(restore_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute restore_delete command by admin role",
tvaultconf.PASS)
LOG.debug(
"Command restore_delete did not execute correctly by admin role"
)
else:
reporting.add_test_step(
"Can not execute restore_delete command by admin role",
tvaultconf.FAIL)
raise Exception(
"Command restore_delete executed correctly by admin role")
# Run snapshot_delete CLI by admin role
snapshot_delete = command_argument_string.snapshot_delete + str(
self.snapshot_id1)
rc = cli_parser.cli_returncode(snapshot_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute snapshot_delete command by admin role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_delete did not execute correctly by admin role"
)
else:
reporting.add_test_step(
"Can not execute snapshot_delete command by admin role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_delete executed correctly by admin role")
# Delete workload with CLI by admin role
workload_delete = command_argument_string.workload_delete + str(
self.wid1)
rc = cli_parser.cli_returncode(workload_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute workload_delete command by admin role",
tvaultconf.PASS)
LOG.debug(
"Command workload_delete did not execute correctly by admin role"
)
else:
reporting.add_test_step(
"Can not execute workload_delete command by admin role",
tvaultconf.FAIL)
raise Exception(
"Command workload_delete executed correctly by admin role")
# Use nonadmin credentials
os.environ['OS_USERNAME'] = CONF.identity.nonadmin_user
os.environ['OS_PASSWORD'] = CONF.identity.nonadmin_password
# Create workload with CLI by default role
workload_create = command_argument_string.workload_create + " --instance instance-id=" + str(
self.restore_vm_id1)
rc = cli_parser.cli_returncode(workload_create)
if rc != 0:
LOG.debug(
"Command workload_create did not execute correctly by default role"
)
reporting.add_test_step(
"Can not execute workload_create command by default role",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Can not execute workload_create command by default role",
tvaultconf.FAIL)
raise Exception(
"Command workload_create executed correctly by default role"
)
# Run snapshot_create CLI by default role
snapshot_create = command_argument_string.snapshot_create + str(
self.wid1)
rc = cli_parser.cli_returncode(snapshot_create)
if rc != 0:
reporting.add_test_step(
"Can not execute snapshot_create command by default role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_create did not execute correctly by default role"
)
else:
reporting.add_test_step(
"Can not execute snapshot_create command by default role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_create executed correctly by default role"
)
# Create one-click restore using CLI by default role
restore_command = command_argument_string.oneclick_restore + " " + str(
self.snapshot_id1)
rc = cli_parser.cli_returncode(restore_command)
if rc != 0:
reporting.add_test_step(
"Can not execute restore_create command by default role",
tvaultconf.PASS)
LOG.debug(
"Command restore_create did not execute correctly by default role"
)
else:
reporting.add_test_step(
"Can not execute restore_create command by default role",
tvaultconf.FAIL)
raise Exception(
"Command restore_create executed correctly by default role"
)
# Run restore_delete CLI by default role
restore_delete = command_argument_string.restore_delete + str(
self.restore_id1)
rc = cli_parser.cli_returncode(restore_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute restore_delete command by default role",
tvaultconf.PASS)
LOG.debug(
"Command restore_delete did not execute correctly by default role"
)
else:
reporting.add_test_step(
"Can not execute restore_delete command by default role",
tvaultconf.FAIL)
raise Exception(
"Command restore_delete executed correctly by default role"
)
# Run snapshot_delete CLI by default role
snapshot_delete = command_argument_string.snapshot_delete + str(
self.snapshot_id1)
LOG.debug("snapshot_delete command: " + str(snapshot_create))
rc = cli_parser.cli_returncode(snapshot_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute snapshot_delete command by default role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_delete did not execute correctly by default role"
)
else:
reporting.add_test_step(
"Can not execute snapshot_delete command by default role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_delete executed correctly by default role"
)
# Delete workload with CLI by default role
workload_delete = command_argument_string.workload_delete + str(
self.wid1)
rc = cli_parser.cli_returncode(workload_delete)
if rc != 0:
reporting.add_test_step(
"Can not execute workload_delete command by default role",
tvaultconf.PASS)
LOG.debug(
"Command workload_delete did not execute correctly by default role"
)
else:
reporting.add_test_step(
"Can not execute workload_delete command by default role",
tvaultconf.FAIL)
raise Exception(
"Command workload_delete executed correctly by default role"
)
# Use backupuser credentials
os.environ['OS_USERNAME'] = CONF.identity.backupuser
os.environ['OS_PASSWORD'] = CONF.identity.backupuser_password
# Run restore_delete CLI by backup role
restore_delete = command_argument_string.restore_delete + str(
self.restore_id1)
rc = cli_parser.cli_returncode(restore_delete)
if rc != 0:
reporting.add_test_step(
"Execute restore_delete command by backup role",
tvaultconf.FAIL)
raise Exception(
"Command restore_delete did not execute correctly by backup role"
)
else:
reporting.add_test_step(
"Execute restore_delete command by backup role",
tvaultconf.PASS)
LOG.debug(
"Command restore_delete executed correctly by backup role")
wc = self.wait_for_snapshot_tobe_available(
self.wid1, self.snapshot_id1)
#Delete restored VM instance and volume
self.delete_restored_vms(self.restore_vm_id1,
self.restore_volume_id1)
LOG.debug("Restored VMs deleted successfully by backup role")
# Run snapshot_delete CLI by backup role
snapshot_delete = command_argument_string.snapshot_delete + str(
self.snapshot_id1)
LOG.debug("snapshot_delete command: " + str(snapshot_create))
rc = cli_parser.cli_returncode(snapshot_delete)
if rc != 0:
reporting.add_test_step(
"Execute snapshot_delete command by backup role",
tvaultconf.FAIL)
raise Exception(
"Command snapshot_delete did not execute correctly by backup role"
)
else:
reporting.add_test_step(
"Execute snapshot_delete command by backup role",
tvaultconf.PASS)
LOG.debug(
"Command snapshot_delete executed correctly by backup role"
)
workload_available = self.wait_for_workload_tobe_available(
self.wid1)
# Delete workload with CLI by backup role
workload_delete = command_argument_string.workload_delete + str(
self.wid1)
rc = cli_parser.cli_returncode(workload_delete)
if rc != 0:
reporting.add_test_step(
"Execute workload_delete command by backup role",
tvaultconf.FAIL)
raise Exception(
"RBAC policy fails for workload deletion by backup role")
else:
LOG.debug("Workload deleted successfully by backup role")
reporting.add_test_step(
"Execute workload_delete command by backup role",
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_booted(self):
try:
### Create vm and workload ###
deleted = 0
reporting.add_test_script(str(__name__))
self.created = False
vm_id = self.create_vm(vm_cleanup=False)
LOG.debug("\nVm id : {}\n".format(str(vm_id)))
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)
LOG.debug("\nworkload id : {}\n".format(str(workload_id)))
LOG.debug("\nvm id : {}\n".format(str(vm_id)))
time.sleep(40)
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")
else:
reporting.add_test_step(
"Execute workload-snapshot command with --full",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
snapshot_id = query_data.get_inprogress_snapshot_id(workload_id)
LOG.debug("\nFull-snapshot ID: {}".format(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)
### Incremental snapshot ###
self.created = False
LOG.debug("workload is:" + str(workload_id))
#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("\nIncremental-snapshot ID: {}".format(
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_list = []
vms_details_after_restore = []
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))
#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
}
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_cleanup=True,
restore_name=tvaultconf.restore_name,
instance_details=instance_details,
network_details=network_details)
LOG.debug("\nselective-restore id : {}\n".format(
str(restore_id_1)))
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)
LOG.debug("Selective restore passed")
else:
reporting.add_test_step("Selective restore", tvaultconf.FAIL)
LOG.debug("Selective restore failed")
raise Exception("Selective restore failed")
LOG.debug("selective restore complete")
#Fetch instance details after restore
restored_vm_details_list = []
vm_list = self.get_restored_vm_list(restore_id_1)
LOG.debug("Restored vm(selective) ID : " + str(vm_list))
for id in range(len(vm_list)):
restored_vm_details_list.append(
self.get_vm_details(vm_list[id]))
LOG.debug("Restored vm details list: " +
str(restored_vm_details_list))
vms_details_after_restore = self.get_vms_details_list(
restored_vm_details_list)
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 with only volume 2 excluded
restore_json = json.dumps({
'openstack': {
'instances': [{
'restore_boot_disk': True,
'include': True,
'id': vm_id
}],
'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)
LOG.debug("\ninplace-restore id : {}\n".format(str(restore_id_2)))
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
restored_vm_details_list = []
vm_list = self.get_restored_vm_list(restore_id_2)
LOG.debug("Restored vm(In-place) ID : " + str(vm_list))
#Delete restore for snapshot
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 ###
#Delete the original instance
self.delete_vm(vm_id)
LOG.debug(
"Instance deleted successfully for one click restore : " +
str(vm_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")
restore_id_3 = query_data.get_snapshot_restore_id(snapshot_id)
LOG.debug("\nRestore ID: {}\n".format(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")
restored_volumes = self.get_restored_volume_list(restore_id_3)
vm_list = self.get_restored_vm_list(restore_id_3)
LOG.debug("Restored vms : " + str(vm_list))
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.delete_vm(vm_id)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
def test_tvault1043_show_workload(self):
try:
#Prerequisites
self.created = False
self.workload_instances = []
#Launch instance
self.vm_id = self.create_vm(vm_name="bootfromvol_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))
#Show workload details using CLI command
rc = cli_parser.cli_returncode(
command_argument_string.workload_show + self.wid)
if rc != 0:
reporting.add_test_step("Execute workload-show command",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step("Execute workload-show command",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
#Compare the workload details against database
out = cli_parser.cli_output(command_argument_string.workload_show +
self.wid)
LOG.debug("Response from DB: " + str(out))
if (query_data.get_workload_display_name(
self.wid) == cli_parser.cli_response_parser(out, 'name')):
reporting.add_test_step("Verify workload name",
tvaultconf.PASS)
else:
reporting.add_test_step("Verify workload name",
tvaultconf.FAIL)
if (query_data.get_workload_display_description(
self.wid) == cli_parser.cli_response_parser(
out, 'description')):
reporting.add_test_step("Verify workload description",
tvaultconf.PASS)
else:
reporting.add_test_step("Verify workload description",
tvaultconf.FAIL)
if (query_data.get_workload_status_by_id(
self.wid) == cli_parser.cli_response_parser(out,
'status')):
reporting.add_test_step("Verify workload status",
tvaultconf.PASS)
else:
reporting.add_test_step("Verify workload status",
tvaultconf.FAIL)
instances_cli = []
temp = json.loads(cli_parser.cli_response_parser(out, 'instances'))
for i in range(0, len(temp)):
instances_cli.append(temp[i]['id'])
instances_cli.sort()
instances_db = query_data.get_workload_vmids(self.wid)
instances_db.sort()
if (instances_db == instances_cli):
reporting.add_test_step("Verify workload instances",
tvaultconf.PASS)
else:
reporting.add_test_step("Verify workload instances",
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_before_upgrade(self):
self.vms_per_workload = 1
self.volume_size = 1
self.workload_instances = []
self.workload_volumes = []
try:
f = open("tempest/upgrade_data_conf.py", "w")
if tvaultconf.global_job_scheduler:
self.scheduler_status = self.enable_global_job_scheduler()
if (self.scheduler_status == 'false'):
reporting.add_test_step(
"Enable global job scheduler", tvaultconf.FAIL)
raise Exception("Enable global job scheduler failed")
else:
reporting.add_test_step(
"Enable global job scheduler", tvaultconf.PASS)
else:
self.scheduler_status = self.disable_global_job_scheduler()
if (self.scheduler_status == 'true'):
reporting.add_test_step(
"Disable global job scheduler", tvaultconf.FAIL)
raise Exception("Disable global job scheduler failed")
else:
reporting.add_test_step(
"Disable global job scheduler", tvaultconf.PASS)
# Fetch license details
self.license_details = self.get_license_list()
LOG.debug("License details: " + str(self.license_details))
f.write("license_details=" + str(self.license_details) + "\n")
# Update user email in openstack
self.update_user_email = self.update_user_email(
CONF.identity.user_id, CONF.identity.user_email, CONF.identity.tenant_id)
f.write("update_user_email_in_openstack=" +
str(self.update_user_email) + "\n")
if self.update_user_email:
reporting.add_test_step(
"Update email for user in openstack", tvaultconf.PASS)
# Fetch existing settings
self.existing_setting = self.get_settings_list()
LOG.debug("Existing setting list: " +
str(self.existing_setting))
# Delete any existing settings
flag = False
if(self.existing_setting != {}):
for k, v in self.existing_setting.items():
if (self.delete_setting(k) == False):
flag = True
if flag:
reporting.add_test_step(
"Delete existing setting", tvaultconf.FAIL)
else:
# Update trilioVault email settings
self.settings_resp = self.update_email_setings(
tvaultconf.setting_data)
f.write("settings_list=" + str(self.settings_resp) + "\n")
self.setting_data_from_resp = {}
for i in range(0, len(self.settings_resp)):
self.setting_data_from_resp[self.settings_resp[i][
'name']] = self.settings_resp[i]['value']
LOG.debug("Settings data from response: " +
str(self.setting_data_from_resp) +
" ; original setting data: " +
str(tvaultconf.setting_data))
if(cmp(self.setting_data_from_resp, tvaultconf.setting_data) == 0):
reporting.add_test_step(
"Update email settings", tvaultconf.PASS)
# Enable email notification for project
self.enable_email_resp = self.update_email_setings(
tvaultconf.enable_email_notification)[0]
f.write("email_enabled_settings=" +
str(self.enable_email_resp) + "\n")
if((str(self.enable_email_resp['name']) == 'smtp_email_enable') and (str(self.enable_email_resp['value']) == '1')):
reporting.add_test_step(
"Enable email notification for project", tvaultconf.PASS)
else:
reporting.add_test_step(
"Enable email notification for project", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
else:
reporting.add_test_step(
"Update email settings", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
else:
reporting.add_test_step(
"Update email for user in openstack", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
# Create workload-1
for vm in range(0, self.vms_per_workload):
volume_id1 = self.create_volume()
self.workload_volumes.append(volume_id1)
vm_id = self.create_vm(vm_cleanup=False)
self.workload_instances.append(vm_id)
f.write("instance_id=" + str(self.workload_instances) + "\n")
self.attach_volume(volume_id1, vm_id, device="/dev/vdb")
f.write("volume_ids=" + str(self.workload_volumes) + "\n")
self.start_date = time.strftime("%x")
self.start_time = time.strftime("%X")
self.jobschedule = {
"fullbackup_interval": "-1",
"retention_policy_type": tvaultconf.retention_policy_type,
"enabled": True,
"start_date": self.start_date,
"start_time": self.start_time,
"interval": tvaultconf.interval,
"retention_policy_value": tvaultconf.retention_policy_value}
self.workload_id = self.workload_create(
self.workload_instances,
tvaultconf.parallel,
self.jobschedule,
workload_cleanup=False)
if(self.wait_for_workload_tobe_available(self.workload_id)):
reporting.add_test_step(
"Create Workload 1 for attached volume instance with scheduler enabled",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Create Workload 1 for attached volume instance with scheduler enabled",
tvaultconf.FAIL)
raise Exception("Workload creation failed")
f.write("workload_id=\"" + str(self.workload_id) + "\"\n")
# Create workload-2
self.volumes = []
self.instances = []
self.volume_id = self.create_volume(
size=tvaultconf.bootfromvol_vol_size,
image_id=CONF.compute.image_ref,
volume_type_id=CONF.volume.volume_type_id)
self.set_volume_as_bootable(self.volume_id)
self.block_mapping_details = [{"source_type": "volume",
"delete_on_termination": "false",
"boot_index": 0,
"uuid": self.volume_id,
"destination_type": "volume"}]
self.volumes.append(self.volume_id)
f.write("volume_ids_2=" + str(self.volumes) + "\n")
self.vm_id = self.create_vm(
image_id="", block_mapping_data=self.block_mapping_details)
self.instances.append(self.vm_id)
f.write("instance_id_2=" + str(self.instances) + "\n")
self.workload_id2 = self.workload_create(
self.instances, tvaultconf.parallel, jobschedule={
'enabled': False}, workload_cleanup=False)
if(self.wait_for_workload_tobe_available(self.workload_id2)):
reporting.add_test_step(
"Create Workload 2 for boot from volume instance with scheduler disabled",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Create Workload 2 for boot from volume instance with scheduler disabled",
tvaultconf.FAIL)
raise Exception("Workload creation failed")
f.write("workload_id_2=\"" + str(self.workload_id2) + "\"\n")
# Fetch workload scheduler and retention settings for workloads
self.workloads = [self.workload_id, self.workload_id2]
for i in range(0, len(self.workloads)):
self.scheduler_settings = self.getSchedulerDetails(
self.workloads[i])
LOG.debug("Workload scheduler settings: " +
str(self.scheduler_settings))
if(i == 0):
f.write("scheduler_settings=" +
str(self.scheduler_settings) + "\n")
else:
f.write("scheduler_settings_2=" +
str(self.scheduler_settings) + "\n")
# Create full snapshots for workloads 1 & 2
self.snapshots = []
for i in range(0, len(self.workloads)):
self.snapshot_id = self.workload_snapshot(
self.workloads[i], True, snapshot_cleanup=False)
self.snapshots.append(self.snapshot_id)
if(i == 0):
f.write("full_snapshot_id=\"" +
str(self.snapshot_id) + "\"\n")
else:
f.write("full_snapshot_id_2=\"" +
str(self.snapshot_id) + "\"\n")
for i in range(0, len(self.workloads)):
self.wait_for_workload_tobe_available(self.workloads[i])
if(self.getSnapshotStatus(self.workloads[i], self.snapshots[i]) == "available"):
reporting.add_test_step(
"Create full snapshot for workload " + str(i + 1), tvaultconf.PASS)
else:
reporting.add_test_step(
"Create full snapshot for workload " + str(i + 1), tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
# Fetch trust details
self.trust_details = self.get_trust_list()
LOG.debug("Trust details: " + str(self.trust_details))
f.write("trust_details=" + str(self.trust_details) + "\n")
f.close()
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_3_modify_workload_scheduler_enable(self):
reporting.add_test_script(str(__name__) + "_scheduler_enable")
try:
#Prerequisites
self.created = False
self.workload_instances = []
#Launch instance
self.vm_id = self.create_vm()
LOG.debug("VM ID-3: " + str(self.vm_id))
#Create volume
self.volume_id = self.create_volume()
LOG.debug("Volume ID-3: " + str(self.volume_id))
#Attach volume to the instance
self.attach_volume(self.volume_id, self.vm_id)
LOG.debug("Volume attached-3")
#Create workload with scheduler disabled using CLI
workload_create = command_argument_string.workload_create + " --instance instance-id=" + str(
self.vm_id) + " --jobschedule enabled=False"
rc = cli_parser.cli_returncode(workload_create)
if rc != 0:
reporting.add_test_step(
"Execute workload-create command with scheduler disable",
tvaultconf.FAIL)
raise Exception(
"Command workload create did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-create command with scheduler disable",
tvaultconf.PASS)
LOG.debug("Command workload create executed correctly")
time.sleep(10)
self.wid = query_data.get_workload_id(tvaultconf.workload_name)
LOG.debug("Workload ID-3: " + str(self.wid))
if (self.wid != None):
self.wait_for_workload_tobe_available(self.wid)
if (self.getWorkloadStatus(self.wid) == "available"):
reporting.add_test_step(
"Create workload with scheduler disable",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Create workload with scheduler disable",
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
else:
reporting.add_test_step(
"Create workload with scheduler disable", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
LOG.debug("Workload ID: " + str(self.wid))
#Verify workload created scheduler disable
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step(
"Verify workload created with scheduler disable",
tvaultconf.FAIL)
raise Exception(
"Workload has not been created with scheduler disabled")
else:
reporting.add_test_step(
"Verify workload created with scheduler disable",
tvaultconf.PASS)
LOG.debug(
"Workload created with scheduler disabled successfully")
#Get workload scheduler details
schedule_details = self.getSchedulerDetails(self.wid)
scheduled_start_time = schedule_details['start_time']
interval = schedule_details['interval']
#Change global job scheduler to disable
LOG.debug("Change Global job scheduler to disable")
status = self.disable_global_job_scheduler()
if not status:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.PASS)
LOG.debug("Global job scheduler disabled successfully")
else:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not disabled")
#Modify workload scheduler to enable
workload_modify_command = command_argument_string.workload_modify + str(
self.wid) + " --jobschedule enabled=True"
error = cli_parser.cli_error(workload_modify_command)
if error and str(
error.strip('\n')
) == "ERROR: Cannot update scheduler related fields when global jobscheduler is disabled.":
reporting.add_test_step(
"Does not execute workload-modify scheduler enable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
reporting.add_test_step("Throws proper message",
tvaultconf.PASS)
LOG.debug("Error message :" + str(error))
else:
reporting.add_test_step(
"Does not execute workload-modify scheduler enable",
tvaultconf.FAIL)
reporting.add_test_step("Throws proper message",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
#Change global job scheduler to enable
LOG.debug("Change Global job scheduler to enable")
status = self.enable_global_job_scheduler()
if status:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.PASS)
LOG.debug("Global job scheduler enabled successfully")
else:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not enabled")
#Modify workload scheduler to enable
workload_modify_command = command_argument_string.workload_modify + str(
self.wid) + " --jobschedule enabled=True"
rc = cli_parser.cli_returncode(workload_modify_command)
if rc != 0:
reporting.add_test_step(
"Execute workload-modify scheduler enable",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-modify scheduler enable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
#Verify workload scheduler changed to enable
self.wait_for_workload_tobe_available(self.wid)
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step("Verify workload scheduler enabled",
tvaultconf.PASS)
LOG.debug("workload scheduler enabled successfully")
else:
reporting.add_test_step("Verify workload scheduler enabled",
tvaultconf.FAIL)
LOG.debug("workload scheduler enabled unsuccessfully")
#Verify interval value and nest_snapshot_run values
schedule_details = self.getSchedulerDetails(self.wid)
interval_after_enable = schedule_details['interval']
next_run_time_after_enable = schedule_details['nextrun']
LOG.debug("interval_after_enable " + str(interval_after_enable))
LOG.debug("next_run_time_after_enable" +
str(next_run_time_after_enable))
scheduled_start_time_periods = ''.join(
[i for i in scheduled_start_time if not i.isdigit()])
scheduled_start_time = ''.join(
[i for i in scheduled_start_time if not i.isalpha()])
current_time = int(time.time())
LOG.debug("current_time " + str(current_time))
start_time = current_time + next_run_time_after_enable
LOG.debug("start_time " + str(start_time))
time3hours = datetime.datetime.utcfromtimestamp(start_time)
start_time_in_hours = time3hours.strftime('%I:%M %p')
start_time_in_periods = ''.join(
[i for i in start_time_in_hours if not i.isdigit()])
start_time_in_hours = ''.join(
[i for i in start_time_in_hours if not i.isalpha()])
LOG.debug("start_time_in_hours " + str(start_time_in_hours))
#Calculate difference between times in minutes
timeA = datetime.datetime.strptime(scheduled_start_time.strip(),
"%H:%M")
timeB = datetime.datetime.strptime(start_time_in_hours.strip(),
"%H:%M")
newTime = timeA - timeB
timedelta = newTime.seconds / 60
#Condition for Interval value and time difference should not be more than two minutes and time periods AM/PM
if timedelta < 2 and scheduled_start_time_periods == start_time_in_periods and interval == interval_after_enable:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.PASS)
LOG.debug(
"Interval and Next snapshot run time values are correct")
else:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.FAIL)
raise Exception(
"Interval and Next snapshot run time values are incorrect")
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()
finally:
#Delete workload
status = self.workload_delete(self.wid)
time.sleep(10)
def test_7_filesearch_wildcards_questionmark(self):
reporting.add_test_script(str(__name__) + "_wildcards_questionmark")
try:
global instances_ids
global snapshot_ids
global wid
global security_group_id
global volumes_ids
# Run Filesearch on vm-1
vmid_to_search = instances_ids[0]
filepath_to_search = "/opt/File_?"
filecount_in_snapshots = {
snapshot_ids[0]: 0,
snapshot_ids[1]: 2,
snapshot_ids[2]: 2,
snapshot_ids[3]: 2}
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 with wildcards_questionmark unsuccessful")
reporting.add_test_step(
"Verification of Filepath serach with wildcards_questionmark",
tvaultconf.FAIL)
raise Exception(
"Filesearch with wildcards_questionmark does not execute correctly")
if filesearch_status:
LOG.debug(
"Filepath_Search with wildcards_questionmark successful")
reporting.add_test_step(
"Verification of Filepath serach with wildcards_questionmark",
tvaultconf.PASS)
# Cleanup
# Delete all snapshots
for snapshot_id in snapshot_ids:
self.snapshot_delete(wid, snapshot_id)
# Delete workload
self.workload_delete(wid)
# Delete VMs
for instance_id in instances_ids:
self.delete_vm(instance_id)
# Delete volumes
for volume_id in volumes_ids:
self.delete_volume(volume_id)
# Delete security group
self.delete_security_group(security_group_id)
# Delete key pair
self.delete_key_pair(tvaultconf.key_pair_name)
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_functional(self):
try:
### VM and Workload ###
tests = [[
'tempest.api.workloadmgr.test_functional_Selective-restore', 0
], ['tempest.api.workloadmgr.test_functional_Inplace-restore', 0]]
reporting.add_test_script(tests[0][0])
vm_count = tvaultconf.vm_count
key_pairs = self.create_kps(vm_count / 3)
LOG.debug("\nKey pairs : {}\n".format(key_pairs))
sec_groups = self.create_sec_groups(vm_count / 3)
LOG.debug("\nSecurity Groups: {}\n".format(sec_groups))
vms, boot_vols = self.multiple_vms(vm_count, key_pairs, sec_groups)
LOG.debug("\nVMs : {}\n".format(vms))
LOG.debug("\nBoot volumes : {}\n".format(boot_vols))
vms = self.attach_vols(vms)
LOG.debug("\nVolumes attached : {}\n".format(vms))
mdsums_original = self.fill_data(vms)
LOG.debug(
"\nMD5 sums before snapshots : {}\n".format(mdsums_original))
wls = self.multiple_workloads(vms)
LOG.debug("\nWorkloads created : {}\n".format(wls))
### Full snapshot ###
fullsnaps = {}
i = 0
for workload_id in wls:
i += 1
snapshot_id = self.workload_snapshot(workload_id,
True,
snapshot_cleanup=True)
time.sleep(5)
self.wait_for_workload_tobe_available(workload_id)
if (self.getSnapshotStatus(workload_id,
snapshot_id) == "available"):
reporting.add_test_step(
"Create full snapshot-{}".format(i), tvaultconf.PASS)
LOG.debug("Full snapshot available!!")
else:
reporting.add_test_step(
"Create full snapshot-{}".format(i), tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
fullsnaps[workload_id] = snapshot_id
LOG.debug("\nFull snapshot ids : {}\n".format(fullsnaps))
#Add some more data to files on VM
volumes_parts = ["/dev/vdb", "/dev/vdc", "/dev/vdd"]
mount_points = ["mount_data_a", "mount_data_b", "mount_data_c"]
for each in vms:
if len(vms[each]) == 3:
ssh = self.SshRemoteMachineConnectionWithRSAKeyName(
str(vms[each][2]), vms[each][0])
i = 0
for each_vol in vms[each][1]:
self.addCustomfilesOnLinuxVM(ssh, mount_points[i], 2)
i += 1
ssh.close()
else:
pass
### Calculate md5sum after filling the data
mdsums_original2 = {}
for vm in vms.keys():
mdsum = ""
fip = ""
j = 0
vmvols = self.get_attached_volumes(vm)
LOG.debug("\nvmvols : {}\n".format(vmvols))
if len(vmvols) > 0:
for vol in vmvols:
if self.volumes_client.show_volume(
vol)['volume']['bootable'] == 'true':
vmvols.remove(vol)
else:
pass
else:
pass
if len(vmvols) > 0:
fip = vms[vm][2]
key = vms[vm][0]
for avolume in vmvols:
LOG.debug("\navolume : {} & j {}\n".format(avolume, j))
mdsum = mdsum + self.calcmd5sum(
fip, key, mount_points[j])
j += 1
mdsums_original2[vm] = mdsum
else:
pass
### Incremental snapshot ###
incrsnaps = {}
i = 0
for workload_id in wls:
i += 1
incr_snapshot_id = self.workload_snapshot(
workload_id, False, snapshot_cleanup=True)
time.sleep(5)
self.wait_for_workload_tobe_available(workload_id)
if (self.getSnapshotStatus(workload_id,
incr_snapshot_id) == "available"):
reporting.add_test_step(
"Create incremental snapshot-{}".format(i),
tvaultconf.PASS)
LOG.debug("Incremental snapshot available!!")
else:
reporting.add_test_step(
"Create incremental snapshot-{}".format(i),
tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
incrsnaps[workload_id] = incr_snapshot_id
LOG.debug("\nIncremental snapshots : {}\n".format(incrsnaps))
### Selective Restore ###
restores = {}
network_details = []
i = 0
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))
#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))
mdsums_sr = {}
instances_details = {}
workloads = wls.items()
for workload in workloads:
i += 1
instance_details = []
wid = workload[0]
snapshotid = fullsnaps[wid]
wlvms = workload[1]
for vmvol in wlvms:
temp_vdisks_data = []
temp_instance_data = {}
vmid = vmvol[0]
vmname = vmid + "_selectively_restored"
volumes = vmvol[1][1]
if len(volumes) == 0:
temp_instance_data = {
'id': vmid,
'availability_zone':
CONF.compute.vm_availability_zone,
'include': True,
'restore_boot_disk': True,
'name': vmname
}
instance_details.append(temp_instance_data)
else:
for volume in volumes:
temp_vdisks_data.append({
'id':
volume,
'availability_zone':
CONF.volume.volume_availability_zone,
'new_volume_type':
CONF.volume.volume_type
})
temp_instance_data = {
'id': vmid,
'availability_zone':
CONF.compute.vm_availability_zone,
'include': True,
'restore_boot_disk': True,
'name': vmname,
'vdisks': temp_vdisks_data
}
instance_details.append(temp_instance_data)
LOG.debug("Instance details for restore: " +
str(instance_details))
instances_details[wid] = instance_details
#Trigger selective restore
restore_id_1 = self.snapshot_selective_restore(
wid,
snapshotid,
restore_name=tvaultconf.restore_name,
restore_cleanup=True,
instance_details=instance_details,
network_details=network_details)
self.wait_for_snapshot_tobe_available(wid, snapshotid)
if (self.getRestoreStatus(wid, snapshotid,
restore_id_1) == "available"):
reporting.add_test_step("Selective restore-{}".format(i),
tvaultconf.PASS)
LOG.debug('selective restore passed')
else:
reporting.add_test_step("Selective restore-{}".format(i),
tvaultconf.FAIL)
LOG.debug('selective restore failed')
raise Exception("Selective restore failed")
restores[restore_id_1] = [wid, snapshotid]
restored_vms = self.get_restored_vm_list(restore_id_1)
LOG.debug("\nRestored vms : {}\n".format(restored_vms))
volumes_parts = ["/dev/vdb", "/dev/vdc", "/dev/vdd"]
mount_points = ["mount_data_a", "mount_data_b", "mount_data_c"]
for rvm in restored_vms:
mdsum = ""
fip = ""
j = 0
rvmname = self.get_vm_details(
rvm)['server']['name'].replace('_selectively_restored',
'')
rvmvols = self.get_attached_volumes(rvm)
LOG.debug("\nrvmvols : {}\n".format(rvmvols))
if len(rvmvols) > 0:
for rvol in rvmvols:
if self.volumes_client.show_volume(
rvol)['volume']['bootable'] == 'true':
rvmvols.remove(rvol)
else:
pass
if len(rvmvols) > 0:
fip = self.assign_floating_ips(rvm, True)
key = vms[rvmname][0]
for rvolume in rvmvols:
LOG.debug("\nrvolume : {} & j {}\n".format(
rvolume, j))
ssh = self.SshRemoteMachineConnectionWithRSAKeyName(
str(fip), key)
self.execute_command_disk_mount(
ssh, str(fip), [volumes_parts[j]],
[mount_points[j]])
ssh.close()
mdsum = mdsum + self.calcmd5sum(
fip, key, mount_points[j])
j += 1
mdsums_sr[rvmname] = mdsum
else:
pass
LOG.debug("MD5SUMS before restore")
LOG.debug(mdsums_original)
LOG.debug("MD5SUMS after restore")
LOG.debug(mdsums_sr)
if cmp(mdsums_original, mdsums_sr) == 0:
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.PASS)
tests[0][1] = 1
reporting.set_test_script_status(tvaultconf.PASS)
reporting.test_case_to_write()
else:
LOG.debug("***MDSUMS DON'T MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
### In-place restore ###
reporting.add_test_script(tests[1][0])
k = 1
workloads = wls.items()
for workload in workloads:
wid = workload[0]
incrsnapid = incrsnaps[wid]
payload = {
"restore": {
"options": {
'name': "inplace-{}".format(wid),
'description': "",
'type': 'openstack',
'oneclickrestore': False,
'restore_type': 'inplace',
'openstack': {
'instances': instances_details[wid],
'networks_mapping': {
'networks': []
}
}
}
}
}
#self.wait_for_snapshot_tobe_available(workload_id, snapshot_id)
resp, body = self.wlm_client.client.post(
"/workloads/" + wid + "/snapshots/" + incrsnapid +
"/restores",
json=payload)
restore_id_2 = body['restore']['id']
LOG.debug(
"#### workloadid: %s ,snapshot_id: %s , restore_id: %s , operation: snapshot_restore"
% (workload_id, incrsnapid, restore_id_2))
LOG.debug("Response:" + str(resp.content))
if (resp.status_code != 202):
resp.raise_for_status()
LOG.debug('Restore of snapshot %s scheduled succesffuly' %
incrsnapid)
if (tvaultconf.cleanup == True):
self.wait_for_snapshot_tobe_available(
workload_id, incrsnapid)
self.restored_vms = self.get_restored_vm_list(restore_id_2)
self.restored_volumes = self.get_restored_volume_list(
restore_id_2)
self.addCleanup(self.restore_delete, workload_id,
incrsnapid, restore_id_2)
self.addCleanup(self.delete_restored_vms,
self.restored_vms, self.restored_volumes)
self.wait_for_snapshot_tobe_available(wid, incrsnapid)
if (self.getRestoreStatus(wid, incrsnapid,
restore_id_2) == "available"):
reporting.add_test_step("In-place restore-{}".format(k),
tvaultconf.PASS)
LOG.debug('In-place restore passed')
else:
reporting.add_test_step("In-place restore-{}".format(k),
tvaultconf.FAIL)
LOG.debug('In-place restore failed')
raise Exception("In-place restore failed")
k += 1
restores[restore_id_2] = [wid, incrsnapid]
mdsums_ipr = {}
restored_vms = self.get_restored_vm_list(restore_id_2)
LOG.debug("\nRestored vms : {}\n".format(restored_vms))
for rvm in vms.keys():
mdsum = ""
fip = ""
j = 0
rvmvols = self.get_attached_volumes(rvm)
LOG.debug("\nrvmvols : {}\n".format(rvmvols))
if len(rvmvols) > 0:
for rvol in rvmvols:
if self.volumes_client.show_volume(
rvol)['volume']['bootable'] == 'true':
rvmvols.remove(rvol)
else:
pass
else:
pass
if len(rvmvols) > 0:
fip = vms[rvm][2]
key = vms[rvm][0]
for rvolume in rvmvols:
LOG.debug("\nrvolume : {} & j {}\n".format(
rvolume, j))
ssh = self.SshRemoteMachineConnectionWithRSAKeyName(
str(fip), key)
self.execute_command_disk_mount(
ssh, str(fip), [volumes_parts[j]],
[mount_points[j]])
ssh.close()
mdsum = mdsum + self.calcmd5sum(
fip, key, mount_points[j])
j += 1
mdsums_ipr[rvm] = mdsum
else:
pass
LOG.debug("MD5SUMS before restore")
LOG.debug(mdsums_original2)
LOG.debug("MD5SUMS after restore")
LOG.debug(mdsums_ipr)
if cmp(mdsums_original2, mdsums_ipr) == 0:
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.PASS)
tests[1][1] = 1
reporting.set_test_script_status(tvaultconf.PASS)
reporting.test_case_to_write()
else:
LOG.debug("***MDSUMS DON'T MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
except Exception as e:
LOG.error("Exception: " + str(e))
for test in tests:
if test[1] != 1:
reporting.add_test_script(test[0])
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
def test_1_filesearch_default_parameters(self):
reporting.add_test_script(str(__name__) + "_default_parameters")
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")
global instances_ids
global snapshot_ids
global date_from
global date_to
global wid
global security_group_id
global volumes_ids
instances_ids = self.instances_ids
snapshot_ids = self.snapshot_ids
date_from = self.date_from
date_to = self.date_to
wid = self.wid
volumes_ids = self.volumes_ids
security_group_id = self.security_group_id
# Run Filesearch on vm-1
vmid_to_search = instances_ids[0]
filepath_to_search = "/opt/File_1"
LOG.debug(
"global parameters: {0} {1} {2} {3} {4} {5} {6}".format(
str(instances_ids),
str(snapshot_ids),
str(date_from),
str(date_to),
str(wid),
str(volumes_ids),
str(security_group_id)))
filecount_in_snapshots = {
snapshot_ids[0]: 0,
snapshot_ids[1]: 1,
snapshot_ids[2]: 1,
snapshot_ids[3]: 1}
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 default_parameters unsuccessful")
reporting.add_test_step(
"Verification of Filepath serach default_parameters",
tvaultconf.FAIL)
raise Exception(
"Filesearch default_parameters does not execute correctly")
if filesearch_status:
LOG.debug("Filepath_Search default_parameters successful")
reporting.add_test_step(
"Verification of Filepath serach default_parameters",
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_chargeback_api(self):
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")
vm_id = self.vm_id
wid = self.wid
chargeback_info = self.getTenantChargeback()
if not chargeback_info:
reporting.add_test_step("Verified Chargeback API",
tvaultconf.FAIL)
LOG.debug("Verified Chargeback API failed")
raise Exception("Verified Chargeback API Failed")
else:
reporting.add_test_step("Verified Chargeback API",
tvaultconf.PASS)
workload_id_chargeback = chargeback_info[str(
CONF.identity.tenant_id)]['tenant_name']
LOG.debug(" Env Tenant ID: " + Tenant_id)
LOG.debug(" Instance ID : " + vm_id)
#Verify workload ID
openstack_workload_ids = chargeback_info[Tenant_id][
'workloads'].keys()
LOG.debug(" Workload ID : " + openstack_workload_ids[1])
for worklad_id in openstack_workload_ids:
if (worklad_id == wid):
LOG.debug(" Workload ID : " + wid)
workload_found = True
if (workload_found == True):
reporting.add_test_step(" Verified workload id ",
tvaultconf.PASS)
else:
reporting.add_test_step(" Verified workload id ",
tvaultconf.FAIL)
raise Exception(" Verification for workload id failed ")
#Verify Instance ID
openstack_instance_ids = chargeback_info[Tenant_id]['workloads'][
wid]['protected_vms'].keys()
LOG.debug(" VM Name : " + openstack_instance_ids[0])
for instance_id in openstack_instance_ids:
if (instance_id == vm_id):
LOG.debug(" VM ID : " + instance_id)
instance_found = True
if (instance_found == True):
reporting.add_test_step(" Verified instance id ",
tvaultconf.PASS)
else:
reporting.add_test_step(" Verified instance id ",
tvaultconf.FAIL)
raise Exception(" Varification for instance id failed ")
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_tenants_usage(self):
try:
# Run getTenantUsage API
Tenant_Usage = self.getTenantUsage()
global_usage_total_vms = Tenant_Usage['global_usage']['total_vms']
LOG.debug(" Total VM In Openstack : " +
str(global_usage_total_vms))
tenants_usage_vms_protected = Tenant_Usage['tenants_usage'][str(
CONF.identity.tenant_id)]['vms_protected']
LOG.debug(" VM Procted in Tenant : " +
str(tenants_usage_vms_protected))
# Run Prereqisite
prerequisites.basic_workload(self)
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")
# Get the openstack global and tenant usage after creating instance
# and workload
Tenant_Usage_after_prereqisite = self.getTenantUsage()
global_usage_total_vms_after_pre_req = Tenant_Usage_after_prereqisite[
'global_usage']['total_vms']
LOG.debug(" Total vms in opensatck after prereqisite run : " +
str(global_usage_total_vms_after_pre_req))
tenants_usage_vms_protected_after_pre_req = Tenant_Usage_after_prereqisite[
'tenants_usage'][CONF.identity.tenant_id]['vms_protected']
LOG.debug(" No. of vms protected after prerequisite : " +
str(tenants_usage_vms_protected_after_pre_req))
# Verify Global Usage
if ((global_usage_total_vms +
1) == global_usage_total_vms_after_pre_req):
LOG.debug(" Global usage total vms value is correct ")
reporting.add_test_step("Verify total vms in openstack",
tvaultconf.PASS)
else:
LOG.debug(" Total vms in openstack is incorrect")
reporting.add_test_step("Verify total vms in openstack",
tvaultconf.FAIL)
raise Exception(
" Verification for total vms in openstack failed ")
# Verify Global Usage
if ((tenants_usage_vms_protected +
1) == tenants_usage_vms_protected_after_pre_req):
LOG.debug(" No. of total protected vms in tenant is correct ")
reporting.add_test_step(
" Verify total protected vms in tenant ", tvaultconf.PASS)
else:
LOG.debug(" No. of total protected vms in tenant is incorrect")
reporting.add_test_step(
" Verify total protected vms in tenant", tvaultconf.FAIL)
raise Exception(
" Verification for protected vms in tenant failed ")
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_3_modify_workload_scheduler_enable(self):
reporting.add_test_script(str(__name__) + "_scheduler_enable")
try:
# Prerequisites
self.created = False
self.workload_instances = []
# Launch instance
self.vm_id = self.create_vm()
LOG.debug("VM ID-3: " + str(self.vm_id))
# Create volume
self.volume_id = self.create_volume()
LOG.debug("Volume ID-3: " + str(self.volume_id))
# Attach volume to the instance
self.attach_volume(self.volume_id, self.vm_id)
LOG.debug("Volume attached-3")
# Create workload with scheduler disabled using CLI
workload_create = command_argument_string.workload_create + \
" --instance instance-id=" + \
str(self.vm_id) + " --jobschedule enabled=False"
rc = cli_parser.cli_returncode(workload_create)
if rc != 0:
reporting.add_test_step(
"Execute workload-create command with scheduler disable",
tvaultconf.FAIL)
raise Exception(
"Command workload create did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-create command with scheduler disable",
tvaultconf.PASS)
LOG.debug("Command workload create executed correctly")
time.sleep(10)
self.wid = query_data.get_workload_id(tvaultconf.workload_name)
LOG.debug("Workload ID-3: " + str(self.wid))
if (self.wid is not None):
self.wait_for_workload_tobe_available(self.wid)
if (self.getWorkloadStatus(self.wid) == "available"):
reporting.add_test_step(
"Create workload with scheduler disable",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Create workload with scheduler disable",
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
else:
reporting.add_test_step(
"Create workload with scheduler disable", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
LOG.debug("Workload ID: " + str(self.wid))
# Verify workload created scheduler disable
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step(
"Verify workload created with scheduler disable",
tvaultconf.FAIL)
raise Exception(
"Workload has not been created with scheduler disabled")
else:
reporting.add_test_step(
"Verify workload created with scheduler disable",
tvaultconf.PASS)
LOG.debug(
"Workload created with scheduler disabled successfully")
# Get workload scheduler details
schedule_details = self.getSchedulerDetails(self.wid)
scheduled_start_time = schedule_details['start_time']
interval = schedule_details['interval']
# Change global job scheduler to disable
LOG.debug("Change Global job scheduler to disable")
status = self.disable_global_job_scheduler()
if not status:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.PASS)
LOG.debug("Global job scheduler disabled successfully")
else:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not disabled")
# Modify workload scheduler to enable
workload_modify_command = command_argument_string.workload_modify + \
str(self.wid) + " --jobschedule enabled=True"
error = cli_parser.cli_error(workload_modify_command)
if error and (str(
error.strip('\n')
).find("Cannot update scheduler related fields when global jobscheduler is disabled."
) != -1):
reporting.add_test_step(
"Does not execute workload-modify scheduler enable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
reporting.add_test_step("Throws proper message",
tvaultconf.PASS)
LOG.debug("Error message :" + str(error))
else:
reporting.add_test_step(
"Does not execute workload-modify scheduler enable",
tvaultconf.FAIL)
reporting.add_test_step("Throws proper message",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
# Change global job scheduler to enable
LOG.debug("Change Global job scheduler to enable")
status = self.enable_global_job_scheduler()
if status:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.PASS)
LOG.debug("Global job scheduler enabled successfully")
else:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not enabled")
# Modify workload scheduler to enable and set the start date, time
# and timezone
now = datetime.datetime.utcnow()
now_date = datetime.datetime.strftime(now, "%m/%d/%Y")
now_time = datetime.datetime.strftime(now, "%I:%M %p")
now_time_plus_15 = now + datetime.timedelta(minutes=15)
now_time_plus_15 = datetime.datetime.strftime(
now_time_plus_15, "%I:%M %p")
workload_modify_command = command_argument_string.workload_modify + str(
self.wid
) + " --jobschedule enabled=True" + " --jobschedule start_date=" + str(
now_date) + " --jobschedule start_time=" + "'" + str(
now_time_plus_15).strip(
) + "'" + " --jobschedule timezone=UTC"
rc = cli_parser.cli_returncode(workload_modify_command)
if rc != 0:
reporting.add_test_step(
"Execute workload-modify scheduler enable",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-modify scheduler enable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
# Verify workload scheduler changed to enable
self.wait_for_workload_tobe_available(self.wid)
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step("Verify workload scheduler enabled",
tvaultconf.PASS)
LOG.debug("workload scheduler enabled successfully")
else:
reporting.add_test_step("Verify workload scheduler enabled",
tvaultconf.FAIL)
LOG.debug("workload scheduler enabled unsuccessfully")
# Verify interval value and nest_snapshot_run values
schedule_details = self.getSchedulerDetails(self.wid)
interval_after_enable = schedule_details['interval']
next_run_time_after_enable = schedule_details['nextrun']
next_run_time_after_enable = int(next_run_time_after_enable)
LOG.debug("interval_after_enable " + str(interval_after_enable))
LOG.debug("next_run_time_after_enable" +
str(next_run_time_after_enable))
start_date = schedule_details['start_date']
start_time = schedule_details['start_time']
date_time = start_date + " " + start_time
start_date_time = datetime.datetime.strptime(
date_time, "%m/%d/%Y %H:%M %p")
LOG.debug("Scheduled start and date time is: " +
str(start_date_time))
utc_24hr = datetime.datetime.utcnow()
utc_12hr = datetime.datetime.strftime(utc_24hr,
"%m/%d/%Y %I:%M %p")
utc_12hr = datetime.datetime.strptime(utc_12hr,
"%m/%d/%Y %H:%M %p")
time_diff = (start_date_time - utc_12hr).total_seconds()
time_diff = int(time_diff)
LOG.debug(
"Time difference between UTC time and scheduled start time: " +
str(time_diff))
delta = abs(time_diff - next_run_time_after_enable)
# Condition for Interval value and time difference should not be
# more than two minutes
if delta < 120 and interval == interval_after_enable:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.PASS)
LOG.debug(
"Interval and Next snapshot run time values are correct")
else:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.FAIL)
raise Exception(
"Interval and Next snapshot run time values are incorrect")
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()
finally:
# Delete workload
status = self.workload_delete(self.wid)
time.sleep(10)
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_1_modify_workload_tvault1045_add_instance(self):
reporting.add_test_script(str(__name__) + "_tvault1045_add_instance")
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 with scheduler enabled
self.workload_instances.append(self.vm_id)
self.wid = self.workload_create(
self.workload_instances,
tvaultconf.parallel,
workload_name=tvaultconf.workload_name,
workload_cleanup=True)
LOG.debug("Workload ID: " + str(self.wid))
# Launch second instance
self.vm_id2 = self.create_vm()
LOG.debug("VM ID2: " + str(self.vm_id2))
# Create volume
self.volume_id2 = self.create_volume()
LOG.debug("Volume ID2: " + str(self.volume_id2))
# Attach volume to the instance
self.attach_volume(self.volume_id2, self.vm_id2)
LOG.debug("Volume2 attached")
# Modify workload to add new instance using CLI command
workload_modify_command = command_argument_string.workload_modify + "--instance instance-id=" + \
str(self.vm_id2) + " --instance instance-id=" + str(self.vm_id) + " " + str(self.wid)
rc = cli_parser.cli_returncode(workload_modify_command)
if rc != 0:
reporting.add_test_step(
"Execute workload-modify command to add one more vm",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-modify command to add one more vm",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
self.wait_for_workload_tobe_available(self.wid)
workload_vm_count = query_data.get_available_vms_of_workload(
self.wid)
if (workload_vm_count == 2):
reporting.add_test_step("Verification with DB",
tvaultconf.PASS)
LOG.debug("Vm has been added successfully")
else:
reporting.add_test_step("Verification with DB",
tvaultconf.FAIL)
raise Exception("Vm has not been added")
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_network_restore(self):
try:
reporting.add_test_script(str(__name__))
self.delete_network_topology()
vms = []
ntwrks = self.create_network()
for network in ntwrks:
if network['name'] in ['Private-1', 'Private-2', 'Private-5']:
vm_name = "instance-{}".format(network['name'])
vmid = self.create_vm(vm_name=vm_name,
networkid=[{
'uuid': network['id']
}],
vm_cleanup=True)
vms.append((vm_name, vmid))
LOG.debug("Launched vms : {}".format(vms))
nws = [x['id'] for x in ntwrks]
nt_bf, sbnt_bf, rt_bf, intf_bf = self.get_topology_details()
vms_ids = [x[1] for x in vms]
workload_id = self.workload_create(vms_ids,
tvaultconf.parallel,
workload_cleanup=True)
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)
raise Exception("Workload creation failed")
snapshot_id = self.workload_snapshot(workload_id,
True,
snapshot_cleanup=True)
time.sleep(5)
self.wait_for_workload_tobe_available(workload_id)
if (self.getSnapshotStatus(workload_id,
snapshot_id) == "available"):
reporting.add_test_step("Create full snapshot",
tvaultconf.PASS)
LOG.debug("Full snapshot available!!")
else:
reporting.add_test_step("Create full snapshot",
tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
instance_details = []
for vm in vms:
temp_instance_data = {
'id': vm[1],
'include': True,
'restore_boot_disk': True,
'name': vm[0] + "restored_instance",
'vdisks': []
}
instance_details.append(temp_instance_data)
LOG.debug("Instance details for restore: " + str(instance_details))
vm_details_bf = {}
for vm in vms:
vm_details_bf[vm[0]] = self.get_vm_details(vm[1])['server']
self.delete_vm(vm[1])
self.delete_network_topology()
restore_id = self.snapshot_selective_restore(
workload_id,
snapshot_id,
restore_name=tvaultconf.restore_name,
instance_details=instance_details,
network_restore_flag=True,
restore_cleanup=True)
self.wait_for_snapshot_tobe_available(workload_id, snapshot_id)
if (self.getRestoreStatus(workload_id, snapshot_id,
restore_id) == "available"):
reporting.add_test_step(
"Selective restore with network restore", tvaultconf.PASS)
else:
reporting.add_test_step(
"Selective restore with network restore", tvaultconf.FAIL)
raise Exception(
"Selective restore with network restore failed")
nt_af, sbnt_af, rt_af, intf_af = self.get_topology_details()
if nt_bf == nt_af:
reporting.add_test_step(
"Verify network details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify network details after network restore",
tvaultconf.FAIL)
LOG.error("Network details before and after restore: {0}, {1}".
format(nt_bf, nt_af))
if sbnt_bf == sbnt_af:
reporting.add_test_step(
"Verify subnet details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify subnet details after network restore",
tvaultconf.FAIL)
LOG.error(
"Subnet details before and after restore: {0}, {1}".format(
sbnt_bf, sbnt_af))
if rt_bf == rt_af:
reporting.add_test_step(
"Verify router details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify router details after network restore",
tvaultconf.FAIL)
LOG.error(
"Router details before and after restore: {0}, {1}".format(
rt_bf, rt_af))
if intf_bf == intf_af:
reporting.add_test_step(
"Verify interface details after network restore",
tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify interface details after network restore",
tvaultconf.FAIL)
LOG.error(
"Interface details before and after restore: {0}, {1}".
format(intf_bf, intf_af))
vm_details_af = {}
restored_vms = self.get_restored_vm_list(restore_id)
for vm in restored_vms:
vm_details = self.get_vm_details(vm)['server']
vm_details_af[vm_details['name'].replace(
'restored_instance', '')] = vm_details
klist = vm_details_bf.keys()
klist.sort()
for vm in klist:
netname = vm_details_bf[vm]['addresses'].keys()[0]
vm_details_bf[vm]['addresses'][netname][0][
'OS-EXT-IPS-MAC:mac_addr'] = ''
vm_details_af[vm]['addresses'][netname][0][
'OS-EXT-IPS-MAC:mac_addr'] = ''
vm_details_bf[vm]['links'][1]['href'] = ''
vm_details_af[vm]['links'][1]['href'] = ''
del vm_details_af[vm]['metadata']['config_drive']
del vm_details_af[vm]['metadata']['ordered_interfaces']
del vm_details_bf[vm]['links']
del vm_details_af[vm]['links']
vm_details_bf[vm]['OS-EXT-SRV-ATTR:instance_name'] = ''
vm_details_af[vm]['OS-EXT-SRV-ATTR:instance_name'] = ''
vm_details_bf[vm]['updated'] = ''
vm_details_af[vm]['updated'] = ''
vm_details_bf[vm]['created'] = ''
vm_details_af[vm]['created'] = ''
vm_details_bf[vm]['id'] = ''
vm_details_af[vm]['id'] = ''
vm_details_bf[vm]['OS-SRV-USG:launched_at'] = ''
vm_details_af[vm]['OS-SRV-USG:launched_at'] = ''
vm_details_af[vm]['name'] = vm_details_af[vm]['name'].replace(
'restored_instance', '')
if vm_details_bf == vm_details_af:
reporting.add_test_step(
"Verify instance details after restore", tvaultconf.PASS)
else:
reporting.add_test_step(
"Verify instance details after restore", tvaultconf.FAIL)
LOG.error(
"Instance details before and after restore: {0}, {1}".
format(vm_details_bf, vm_details_af))
for rvm in restored_vms:
self.delete_vm(rvm)
self.delete_network_topology()
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_tvault1290_delete_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
wc = query_data.get_workload_snapshot_status(
tvaultconf.snapshot_name, tvaultconf.snapshot_type_full,
self.snapshot_id)
LOG.debug("Workload snapshot status: " + str(wc))
while (str(wc) != "available" or str(wc) != "error"):
time.sleep(5)
wc = query_data.get_workload_snapshot_status(
tvaultconf.snapshot_name, tvaultconf.snapshot_type_full,
self.snapshot_id)
LOG.debug("Workload snapshot status: " + str(wc))
if (str(wc) == "available"):
LOG.debug("Workload snapshot successfully completed")
self.created = True
break
else:
if (str(wc) == "error"):
break
if (self.created == False):
raise Exception("Workload snapshot did not get created")
#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,
restore_cleanup=False)
LOG.debug("Restore ID: " + str(self.restore_id))
self.wait_for_snapshot_tobe_available(self.wid, self.snapshot_id)
self.restore_vm_id = self.get_restored_vm_list(self.restore_id)
LOG.debug("Restore VM ID: " + str(self.restore_vm_id))
self.restore_volume_id = self.get_restored_volume_list(
self.restore_id)
LOG.debug("Restore Volume ID: " + str(self.restore_volume_id))
#Delete restore for snapshot using CLI command
rc = cli_parser.cli_returncode(
command_argument_string.restore_delete + self.restore_id)
if rc != 0:
reporting.add_test_step("Execute restore-delete command",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step("Execute restore-delete command",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
time.sleep(5)
wc = query_data.get_snapshot_restore_delete_status(
tvaultconf.restore_name, tvaultconf.restore_type)
if (str(wc) == "1"):
reporting.add_test_step("Verification", tvaultconf.PASS)
LOG.debug("Snapshot restore successfully deleted")
else:
reporting.add_test_step("Verification", tvaultconf.FAIL)
raise Exception("Restore did not get deleted")
#Cleanup
#Delete restored VM instance and volume
self.delete_restored_vms(self.restore_vm_id,
self.restore_volume_id)
LOG.debug("Restored VMs 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()
def test_retention(self):
try:
vm_id = self.create_vm(vm_cleanup=True)
LOG.debug("VM ID : " + str(vm_id))
i = 1
jobschedule = {
'retention_policy_type': 'Number of Snapshots to Keep',
'retention_policy_value': '3',
'full_backup_interval': '2'
}
rpv = int(jobschedule['retention_policy_value'])
workload_id = self.workload_create([vm_id],
tvaultconf.parallel,
jobschedule=jobschedule,
workload_cleanup=True)
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)
raise Exception("Workload creation failed")
for i in range(0, (rpv + 1)):
snapshot_id = self.workload_snapshot(workload_id,
True,
snapshot_cleanup=False)
self.wait_for_workload_tobe_available(workload_id)
if (self.getSnapshotStatus(workload_id,
snapshot_id) == "available"):
reporting.add_test_step(
"Create full snapshot-{}".format(i + 1),
tvaultconf.PASS)
LOG.debug("Full snapshot available!!")
else:
reporting.add_test_step(
"Create full snapshot-{}".format(i + 1),
tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
snapshotlist = self.getSnapshotList(workload_id=workload_id)
if len(snapshotlist) == rpv:
reporting.add_test_step("Retention", tvaultconf.PASS)
LOG.debug("Retention worked!!")
else:
reporting.add_test_step("Retention", tvaultconf.FAIL)
LOG.debug("Retention didn't work!!")
raise Exception("Retention failed")
if (tvaultconf.cleanup == True):
for snapshot in snapshotlist:
self.addCleanup(self.snapshot_delete, workload_id,
snapshot)
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_3_config_workload_reconfigure(self):
reporting.add_test_script(
str(__name__) + "_reconfigure_additional_dir")
try:
# prerequisite handles config_user creation and config_backup_pvk(private key) creation
# for config backup configuration, yaml_file creation
added_dir = {
'tvault-contego': {
'config_dir': ['/etc/tvault-contego/']
}
}
self.create_config_backup_yaml(added_dir=added_dir)
# config backup configuration with CLI command
config_workload_command = command_argument_string.config_workload_configure + " --config-file yaml_file.yaml --authorized-key config_backup_pvk "
LOG.debug("config workload configure cli command: " +
str(config_workload_command))
rc = cli_parser.cli_returncode(config_workload_command)
if rc != 0:
reporting.add_test_step(
"Triggering config_workload_configure command via CLI",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Triggering config_workload_configure command via CLI",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
config_workload_show_command = command_argument_string.config_workload_show
config_workload_output = cli_parser.cli_output(
config_workload_show_command)
LOG.debug("config_workload_show_command output from cli: " +
str(config_workload_output))
if added_dir.keys()[0] in str(config_workload_output):
LOG.debug("config_workload output with added dir: " +
added_dir.keys()[0] + " : " +
str(config_workload_output))
reporting.add_test_step(
"config_workload completed with added dir ",
tvaultconf.PASS)
else:
LOG.debug("config_workload output without added dir: " +
added_dir.keys()[0] + " : " +
str(config_workload_output))
reporting.add_test_step(
"config_workload completed with added dir ",
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_1_volume_volume(self):
try:
### VM and Workload ###
reporting.add_test_script(str(__name__))
deleted = 0
global volumes
mount_points = ["mount_data_a", "mount_data_b"]
md5sums_dir_before = {}
#Create Keypair
kp = self.create_key_pair(tvaultconf.key_pair_name,
keypair_cleanup=True)
LOG.debug("Key_pair : " + str(kp))
#Create bootable volume
boot_volume_id = self.create_volume(
size=tvaultconf.bootfromvol_vol_size,
image_id=CONF.compute.image_ref,
volume_cleanup=False)
self.set_volume_as_bootable(boot_volume_id)
LOG.debug("Bootable Volume ID : " + str(boot_volume_id))
self.block_mapping_details = [{
"source_type": "volume",
"delete_on_termination": "false",
"boot_index": 0,
"uuid": boot_volume_id,
"destination_type": "volume"
}]
#Create instance
vm_id = self.create_vm(
key_pair=kp,
image_id="",
block_mapping_data=self.block_mapping_details,
vm_cleanup=False)
LOG.debug("VM ID : " + str(vm_id))
time.sleep(30)
#Create and attach volume
volume_id = self.create_volume(
volume_type_id=CONF.volume.volume_type_id,
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")
#Assign floating IP
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)
#Adding data and calculating md5sums
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)
LOG.debug("Sleeping for 40s")
time.sleep(40)
#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 + "_selectively_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(60)
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 before restore")
LOG.debug(md5sums_dir_before[str(floating_ip_1)])
LOG.debug("MD5SUMS after restore")
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 with only volume 2 excluded
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 = []
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)
#Delete restore for snapshot
if (tvaultconf.cleanup == True):
self.addCleanup(self.restore_delete, workload_id,
incr_snapshot_id, restore_id_2)
### 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 bootable volume of original instance
self.delete_volume(boot_volume_id)
LOG.debug("Bootable volume of original instance deleted")
#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")
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 = []
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 = []
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)
time.sleep(30)
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)
self.delete_volume(boot_volume_id)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
def test_email(self):
try:
# Fetch existing settings
existing_setting = self.get_settings_list()
LOG.debug("Existing setting list: " + str(existing_setting))
# Delete any existing settings
flag = False
if (existing_setting != {}):
for k, v in existing_setting.items():
if (self.delete_setting(k) == False):
flag = True
if flag:
reporting.add_test_step("Delete existing setting",
tvaultconf.FAIL)
else:
# Update trilioVault email settings
settings_resp = self.update_email_setings(
tvaultconf.setting_data)
setting_data_from_resp = {}
for i in range(0, len(settings_resp)):
setting_data_from_resp[
settings_resp[i]['name']] = settings_resp[i]['value']
LOG.debug("Settings data from response: " +
str(setting_data_from_resp) +
" ; original setting data: " +
str(tvaultconf.setting_data))
if (operator.eq(setting_data_from_resp,
tvaultconf.setting_data)):
reporting.add_test_step("Update email settings",
tvaultconf.PASS)
# Enable email notification for project
enable_email_resp = self.update_email_setings(
tvaultconf.enable_email_notification)[0]
if ((str(enable_email_resp['name']) == 'smtp_email_enable')
and (str(enable_email_resp['value']) == '1')):
reporting.add_test_step(
"Enable email notification for project",
tvaultconf.PASS)
self.wlm_client.client.get(
"/workloads/email/test_email")
cmd = 'curl -u ' + tvaultconf.setting_data["smtp_default_recipient"] + ':' + \
tvaultconf.tvault_password + ' --silent "https://mail.google.com/mail/feed/atom"'
op = subprocess.check_output(cmd, shell=True)
if len(
re.findall(
'Testing email configuration',
op.decode().split('<entry>')[1])) == 1:
LOG.debug(
"Email testing done correctly and email is : {}"
.format(op))
reporting.add_test_step("Test email",
tvaultconf.PASS)
else:
reporting.add_test_step("Test email",
tvaultconf.FAIL)
existing_setting = self.get_settings_list()
LOG.debug("Existing setting list: " +
str(existing_setting))
# Delete the existing settings
for k, v in existing_setting.items():
self.delete_setting(k)
else:
reporting.add_test_step(
"Enable email notification for project",
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
else:
reporting.add_test_step("Update email settings",
tvaultconf.FAIL)
reporting.set_test_script_status(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_ubuntu_smallvolumes_selectiverestore_defaultsdeleted(self):
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.delete_vms(self.workload_instances)
self.delete_volumes(self.workload_volumes)
self.delete_key_pair(tvaultconf.key_pair_name)
self.delete_security_group(self.security_group_id)
self.delete_flavor(self.flavor_id)
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))
#Create instance details for restore.json
temp_vdisks_data = []
for i in range(len(self.workload_instances)):
flag = i + i
temp_vdisks_data.append([{
'id':
self.workload_volumes[flag],
'availability_zone':
CONF.volume.volume_availability_zone,
'new_volume_type':
CONF.volume.volume_type
}, {
'id':
self.workload_volumes[flag + 1],
'availability_zone':
CONF.volume.volume_availability_zone,
'new_volume_type':
CONF.volume.volume_type
}])
LOG.debug("Vdisks details for restore" + str(temp_vdisks_data))
for i in range(len(self.workload_instances)):
vm_name = "tempest_test_vm_" + str(i + 1) + "_restored"
temp_instance_data = {
'id': self.workload_instances[i],
'availability_zone': CONF.compute.vm_availability_zone,
'include': True,
'restore_boot_disk': True,
'name': vm_name,
'vdisks': temp_vdisks_data[i]
}
self.instance_details.append(temp_instance_data)
LOG.debug("Instance details for restore: " +
str(self.instance_details))
#Create network details for restore.json
snapshot_network = {
'name': int_net_1_name,
'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
}
}
self.network_details = [{
'snapshot_network': snapshot_network,
'target_network': target_network
}]
LOG.debug("Network details for restore: " +
str(self.network_details))
#Trigger selective restore
self.restore_id = self.snapshot_selective_restore(
self.workload_id,
self.snapshot_id,
restore_name=tvaultconf.restore_name,
instance_details=self.instance_details,
network_details=self.network_details,
sec_group_cleanup=True)
self.wait_for_snapshot_tobe_available(self.workload_id,
self.snapshot_id)
if (self.getRestoreStatus(self.workload_id, self.snapshot_id,
self.restore_id) == "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
self.restored_vm_details_list = []
self.vm_list = self.get_restored_vm_list(self.restore_id)
LOG.debug("Restored vms : " + str(self.vm_list))
for id in range(len(self.vm_list)):
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))
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))
#Compare the data before and after restore
for i in range(len(self.vms_details_after_restore)):
if (self.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(self.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)
if (self.get_key_pair_details(
self.vms_details_after_restore[i]['keypair']) ==
self.original_fingerprint):
reporting.add_test_step(
"Keypair verification for instance-" + str(i + 1),
tvaultconf.PASS)
else:
LOG.error("Original keypair details: " +
str(self.original_fingerprint))
LOG.error("Restored keypair details: " + str(
self.get_key_pair_details(
self.vms_details_after_restore[i]['keypair'])))
reporting.add_test_step(
"Keypair verification for instance-" + str(i + 1),
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
if (self.get_flavor_details(
self.vms_details_after_restore[i]['flavor_id']) ==
self.original_flavor_conf):
reporting.add_test_step(
"Flavor verification for instance-" + str(i + 1),
tvaultconf.PASS)
else:
LOG.error("Original flavor details: " +
str(self.original_flavor_conf))
LOG.error("Restored flavor details: " + str(
self.get_flavor_details(
self.vms_details_after_restore[i]['flavor_id'])))
reporting.add_test_step(
"Flavor verification for instance-" + str(i + 1),
tvaultconf.FAIL)
reporting.set_test_script_status(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_1_image_booted(self):
try:
deleted = 0
## VM and Workload ###
tests = [['tempest.api.workloadmgr.restore.test_image_booted_Selective-restore',0], ['tempest.api.workloadmgr.restore.test_image_booted_Inplace-restore',0], ['tempest.api.workloadmgr.restore.test_image_booted_Oneclick-restore',0]]
reporting.add_test_script(tests[0][0])
data_dir_path = "/root"
md5sums_before_full = {}
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))
time.sleep(30)
floating_ip_1 = self.assign_floating_ips(vm_id, False)
LOG.debug("Assigned floating IP : "+str(floating_ip_1))
LOG.debug("Sleeping for 20 sec")
time.sleep(20)
self.data_ops(floating_ip_1, data_dir_path, 3)
LOG.debug("Created data")
md5sums_before_full = self.calcmd5sum(floating_ip_1, data_dir_path)
LOG.debug("MD5sums for directory on original vm : "+str(md5sums_before_full))
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)
raise Exception("Workload creation failed")
else:
reporting.add_test_step("Create workload", tvaultconf.FAIL)
raise Exception("Workload creation failed")
if (tvaultconf.cleanup == True):
self.addCleanup(self.workload_delete, workload_id)
### Full snapshot ###
snapshot_id = self.create_snapshot(workload_id, is_full=True)
#Add some more data to files on VM
ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1))
self.addCustomfilesOnLinuxVM(ssh, data_dir_path, 2)
ssh.close()
md5sums_before_incremental = {}
md5sums_before_incremental = self.calcmd5sum(floating_ip_1, data_dir_path)
LOG.debug("\nMD5SUM after adding additional data before incremental snapshot : {}\n".format(md5sums_before_incremental))
### Incremental snapshot ###
incr_snapshot_id = self.create_snapshot(workload_id, is_full=False)
### Selective restore ###
rest_details = {}
rest_details['rest_type'] = 'selective'
rest_details['network_id'] = CONF.network.internal_network_id
rest_details['subnet_id'] = self.get_subnet_id(CONF.network.internal_network_id)
volumeslist = []
rest_details['instances'] = {vm_id:volumeslist}
payload = self.create_restore_json(rest_details)
#Trigger selective restore
restore_id_1=self.snapshot_selective_restore(workload_id, snapshot_id,restore_name=tvaultconf.restore_name, restore_cleanup=True,
instance_details=payload['instance_details'], network_details=payload['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(60)
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_after_selective = {}
ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_2))
md5sums_after_selective = self.calcmd5sum(floating_ip_2, data_dir_path)
ssh.close()
LOG.debug("MD5SUMS before restore")
LOG.debug(md5sums_before_full[str(floating_ip_1)])
LOG.debug("MD5SUMS after selective restore")
LOG.debug(md5sums_after_selective[str(floating_ip_2)])
if md5sums_before_full[str(floating_ip_1)] == md5sums_after_selective[str(floating_ip_2)]:
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS)
reporting.set_test_script_status(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_vm_details = []
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
int_net_1_name = self.get_net_name(CONF.network.internal_network_id)
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)
tests[0][1] = 1
reporting.test_case_to_write()
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)
reporting.test_case_to_write()
### In-place Restore ###
rest_details = {}
rest_details['rest_type'] = 'inplace'
rest_details['instances'] = {vm_id:volumeslist}
reporting.add_test_script(tests[1][0])
#Create in-place restore with CLI command
restore_command = command_argument_string.inplace_restore + str(tvaultconf.restore_filename) + " " + str(snapshot_id)
payload = self.create_restore_json(rest_details)
restore_json = json.dumps(payload)
LOG.debug("restore.json for inplace restore: " + str(restore_json))
#Create Restore.json
with open(tvaultconf.restore_filename, 'w') as f:
f.write(str(yaml.safe_load(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(snapshot_id)
self.wait_for_snapshot_tobe_available(workload_id, snapshot_id)
#get in-place restore status
if(self.getRestoreStatus(workload_id, 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 = []
vm_list = self.get_restored_vm_list(restore_id_2)
LOG.debug("Restored vm(In-place) ID : " + str(vm_list))
time.sleep(60)
md5sums_after_inplace = {}
ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1))
md5sums_after_inplace = self.calcmd5sum(floating_ip_1, data_dir_path)
ssh.close()
LOG.debug("<----md5sums_before_full---->")
LOG.debug(md5sums_before_full[str(floating_ip_1)])
LOG.debug("<----md5sums_after_inplace---->")
LOG.debug(md5sums_after_inplace[str(floating_ip_1)])
if md5sums_before_full[str(floating_ip_1)] == md5sums_after_inplace[str(floating_ip_1)]:
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS)
tests[1][1] = 1
reporting.set_test_script_status(tvaultconf.PASS)
reporting.test_case_to_write()
else:
LOG.debug("***MDSUMS DON'T MATCH***")
reporting.add_test_step("Md5 Verification for volume", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
#Delete restore for snapshot
if (tvaultconf.cleanup == True):
self.addCleanup(self.restore_delete, workload_id, snapshot_id, restore_id_2)
### One-click restore ###
reporting.add_test_script(tests[2][0])
#Delete the original instance
self.delete_vm(vm_id)
LOG.debug("Instance deleted successfully for one click restore : "+str(vm_id))
time.sleep(10)
deleted = 1
#Create one-click restore using CLI command
restore_command = command_argument_string.oneclick_restore + " " + incr_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")
restore_id_3 = query_data.get_snapshot_restore_id(incr_snapshot_id)
LOG.debug("Restore ID: " + str(restore_id_3))
self.wait_for_snapshot_tobe_available(workload_id, incr_snapshot_id)
if(self.getRestoreStatus(workload_id, incr_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 = []
vm_list = self.get_restored_vm_list(restore_id_3)
LOG.debug("Restored vms : " + str(vm_list))
md5sums_after_1clickrestore = {}
ssh = self.SshRemoteMachineConnectionWithRSAKey(str(floating_ip_1))
md5sums_after_1clickrestore = self.calcmd5sum(floating_ip_1, data_dir_path)
LOG.debug("MD5SUMS after one click restore : {}".format(md5sums_after_1clickrestore))
ssh.close()
if md5sums_before_incremental[str(floating_ip_1)] == md5sums_after_1clickrestore[str(floating_ip_1)]:
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification for volume", tvaultconf.PASS)
tests[2][0] = 1
reporting.set_test_script_status(tvaultconf.PASS)
reporting.test_case_to_write()
else:
LOG.debug("***MDSUMS DON'T MATCH***")
reporting.add_test_step("Md5 Verification for volume", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
restored_volumes = []
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, incr_snapshot_id, restore_id_3)
time.sleep(30)
self.addCleanup(self.delete_restored_vms, vm_list, restored_volumes)
except Exception as e:
LOG.error("Exception: " + str(e))
if (deleted == 0):
try:
self.delete_vm(vm_id)
except:
pass
for test in tests:
if test[1] != 1:
reporting.add_test_script(test[0])
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
def test_tvault1047_unlock_workload(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))
wc = query_data.get_workload_status_by_id(self.wid)
LOG.debug("Workload status: " + str(wc))
# Unlock workload using CLI command
rc = cli_parser.cli_returncode(
command_argument_string.workload_unlock + self.wid)
if rc != 0:
reporting.add_test_step("Execute workload-unlock command",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step("Execute workload-unlock command",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
# Get workload status
wc = query_data.get_workload_status_by_id(self.wid)
LOG.debug("Workload status: " + str(wc))
if ('available' == str(wc)):
reporting.add_test_step("Verification", tvaultconf.PASS)
else:
raise Exception("Workload status update failed")
try:
self.wait_for_snapshot_tobe_available(self.wid,
self.snapshot_id)
LOG.debug("Snapshot is available")
except Exception as e:
LOG.error("Snapshot is in error state")
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_5_regression(self):
reporting.add_test_script(
str(__name__) + "_selective_restore_bootfromvol")
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
volumes = tvaultconf.volumes_parts
mount_points = ["mount_data_b", "mount_data_c"]
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))
#Create instance details for restore.json
for i in range(len(self.workload_instances)):
vm_name = "tempest_test_vm_" + str(i + 1) + "_restored"
temp_instance_data = {
'id': self.workload_instances[i],
'include': True,
'restore_boot_disk': True,
'name': vm_name,
'vdisks': []
}
self.instance_details.append(temp_instance_data)
LOG.debug("Instance details for restore: " +
str(self.instance_details))
#Create network details for restore.json
snapshot_network = {
'name': int_net_1_name,
'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
}
}
self.network_details = [{
'snapshot_network': snapshot_network,
'target_network': target_network
}]
LOG.debug("Network details for restore: " +
str(self.network_details))
#Fill some more data on each volume attached
tree = lambda: collections.defaultdict(tree)
self.md5sums_dir_before = tree()
for floating_ip in self.floating_ips_list:
for mount_point in mount_points:
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(floating_ip))
self.addCustomSizedfilesOnLinux(ssh, mount_point, 5)
ssh.close()
for mount_point in mount_points:
ssh = self.SshRemoteMachineConnectionWithRSAKey(
str(floating_ip))
self.md5sums_dir_before[str(floating_ip)][str(
mount_point)] = self.calculatemmd5checksum(
ssh, mount_point)
ssh.close()
LOG.debug("md5sums_dir_before" + str(self.md5sums_dir_before))
#Trigger selective restore
self.restore_id = self.snapshot_selective_restore(
self.workload_id,
self.snapshot_id,
restore_name=tvaultconf.restore_name,
instance_details=self.instance_details,
network_details=self.network_details)
self.wait_for_snapshot_tobe_available(self.workload_id,
self.snapshot_id)
if (self.getRestoreStatus(self.workload_id, self.snapshot_id,
self.restore_id) == "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
self.restored_vm_details_list = []
self.vm_list = self.get_restored_vm_list(self.restore_id)
LOG.debug("Restored vms : " + str(self.vm_list))
for id in range(len(self.vm_list)):
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))
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))
#Compare the data before and after restore
for i in range(len(self.vms_details_after_restore)):
if (self.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(self.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)
if (self.get_key_pair_details(
self.vms_details_after_restore[i]['keypair']) ==
self.original_fingerprint):
reporting.add_test_step(
"Keypair verification for instance-" + str(i + 1),
tvaultconf.PASS)
else:
LOG.error("Original keypair details: " +
str(self.original_fingerprint))
LOG.error("Restored keypair details: " + str(
self.get_key_pair_details(
self.vms_details_after_restore[i]['keypair'])))
reporting.add_test_step(
"Keypair verification for instance-" + str(i + 1),
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
if (self.get_flavor_details(
self.vms_details_after_restore[i]['flavor_id']) ==
self.original_flavor_conf):
reporting.add_test_step(
"Flavor verification for instance-" + str(i + 1),
tvaultconf.PASS)
else:
LOG.error("Original flavor details: " +
str(self.original_flavor_conf))
LOG.error("Restored flavor details: " + str(
self.get_flavor_details(
self.vms_details_after_restore[i]['flavor_id'])))
reporting.add_test_step(
"Flavor verification for instance-" + str(i + 1),
tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
#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_selective_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_selective_restore[str(floating_ip)][str(
mount_point)] = self.calculatemmd5checksum(
ssh, mount_point)
ssh.close()
LOG.debug("md5_sum_after_selective_restore" +
str(md5_sum_after_selective_restore))
#md5sum verification
if (self.md5sums_dir_before == md5_sum_after_selective_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_2_modify_workload_scheduler_disable(self):
reporting.add_test_script(str(__name__) + "_scheduler_disable")
try:
# Prerequisites
self.created = False
self.workload_instances = []
# Launch instance
self.vm_id = self.create_vm()
LOG.debug("VM ID-2: " + str(self.vm_id))
# Create volume
self.volume_id = self.create_volume()
LOG.debug("Volume ID-2: " + str(self.volume_id))
# Attach volume to the instance
self.attach_volume(self.volume_id, self.vm_id)
LOG.debug("Volume attached-2")
# Create workload with scheduler enabled
self.workload_instances.append(self.vm_id)
self.wid = self.workload_create(
self.workload_instances,
tvaultconf.parallel,
workload_name=tvaultconf.workload_name,
workload_cleanup=True)
LOG.debug("Workload ID-2: " + str(self.wid))
# Verify workload created with scheduler enable
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step(
"Workload created with scheduler enabled", tvaultconf.PASS)
LOG.debug(
"Workload created with scheduler enabled successfully")
else:
reporting.add_test_step(
"Workload created with scheduler enabled", tvaultconf.FAIL)
raise Exception(
"Workload has not been created with scheduler enabled")
# Get workload scheduler details
schedule_details = self.getSchedulerDetails(self.wid)
scheduled_start_time = schedule_details['start_time']
interval = schedule_details['interval']
# Change global job scheduler to disable
LOG.debug("Change Global job scheduler to disable")
status = self.disable_global_job_scheduler()
if not status:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.PASS)
LOG.debug("Global job scheduler disabled successfully")
else:
reporting.add_test_step("Global job scheduler disable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not disabled")
# Modify workload scheduler to disable
workload_modify_command = command_argument_string.workload_modify + \
str(self.wid) + " --jobschedule enabled=False"
error = cli_parser.cli_error(workload_modify_command)
if error and (str(
error.strip('\n')
).find("Cannot update scheduler related fields when global jobscheduler is disabled."
) != -1):
reporting.add_test_step(
"Does not execute workload-modify scheduler disable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
reporting.add_test_step("Throws proper message",
tvaultconf.PASS)
LOG.debug("Error message :" + str(error))
else:
reporting.add_test_step(
"Does not execute workload-modify scheduler disable",
tvaultconf.FAIL)
reporting.add_test_step("Throws proper message",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
# Change global job scheduler to enable
LOG.debug("Change Global job scheduler to enable")
status = self.enable_global_job_scheduler()
if status:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.PASS)
LOG.debug("Global job scheduler enabled successfully")
else:
reporting.add_test_step("Global job scheduler enable",
tvaultconf.FAIL)
raise Exception("Global job scheduler not enabled")
# Modify workload scheduler to disable using CLI command
workload_modify_command = command_argument_string.workload_modify + \
str(self.wid) + " --jobschedule enabled=False"
rc = cli_parser.cli_returncode(workload_modify_command)
if rc != 0:
reporting.add_test_step(
"Execute workload-modify scheduler disable",
tvaultconf.FAIL)
raise Exception("Command did not execute correctly")
else:
reporting.add_test_step(
"Execute workload-modify scheduler disable",
tvaultconf.PASS)
LOG.debug("Command executed correctly")
# Verify workload scheduler changed to disable
status = self.getSchedulerStatus(self.wid)
if status:
reporting.add_test_step("Verify workload scheduler disabled",
tvaultconf.FAIL)
LOG.debug("workload scheduler disabled unsuccessfully")
else:
reporting.add_test_step("Verify workload scheduler disabled",
tvaultconf.PASS)
LOG.debug("workload scheduler disabled successfully")
# Verify interval value and nest_snapshot_run values
schedule_details = self.getSchedulerDetails(self.wid)
interval_after_disable = schedule_details['interval']
if interval == interval_after_disable and 'nextrun' not in schedule_details:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.PASS)
LOG.debug(
"Interval and Next snapshot run time values are correct")
else:
reporting.add_test_step(
"Verify Interval and Next snapshot run time values are correct",
tvaultconf.FAIL)
raise Exception(
"Interval and Next snapshot run time values are incorrect")
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_functional(self):
try:
### VM and Workload ###
reporting.add_test_script('tempest.api.workloadmgr.test_functional_oneclick_restore')
status = 0
deleted = 0
vm_count = tvaultconf.vm_count
key_pairs = self.create_kps(vm_count/3)
LOG.debug("\nKey pairs : {}\n".format(key_pairs))
sec_groups = self.create_sec_groups(vm_count/3)
LOG.debug("\nSecurity Groups: {}\n".format(sec_groups))
vms,boot_vols = self.multiple_vms(vm_count, key_pairs, sec_groups)
LOG.debug("\nVMs : {}\n".format(vms))
LOG.debug("\nBoot volumes : {}\n".format(boot_vols))
vms = self.attach_vols(vms)
LOG.debug("\nVolumes attached : {}\n".format(vms))
mdsums_original = self.fill_data(vms)
LOG.debug("\nMD5 sums before snapshots : {}\n".format(mdsums_original))
wls = self.multiple_workloads(vms)
LOG.debug("\nWorkloads created : {}\n".format(wls))
### Full snapshot ###
fullsnaps = {}
i = 0
for workload_id in wls:
i+=1
snapshot_id=self.workload_snapshot(workload_id, True, snapshot_cleanup=True)
time.sleep(5)
self.wait_for_workload_tobe_available(workload_id)
if(self.getSnapshotStatus(workload_id, snapshot_id) == "available"):
reporting.add_test_step("Create full snapshot-{}".format(i), tvaultconf.PASS)
LOG.debug("Full snapshot available!!")
else:
reporting.add_test_step("Create full snapshot-{}".format(i), tvaultconf.FAIL)
raise Exception("Snapshot creation failed")
fullsnaps[workload_id] = snapshot_id
LOG.debug("\nFull snapshot ids : {}\n".format(fullsnaps))
### One-click Restore ###
self.delete_vms(vms.keys())
time.sleep(60)
deleted = 1
restores = {}
i = 0
mdsums_oc = {}
instances_details = {}
workloads = wls.items()
for workload in workloads:
i+=1
instance_details = []
wid = workload[0]
snapshotid = fullsnaps[wid]
wlvms = workload[1]
# Triggger one click restore #
restore_id = self.snapshot_restore(wid, snapshotid, restore_cleanup=True)
self.wait_for_snapshot_tobe_available(wid, snapshotid)
if(self.getRestoreStatus(wid, snapshotid, restore_id) == "available"):
reporting.add_test_step("Oneclick-{}".format(i), tvaultconf.PASS)
LOG.debug('Oneclick restore passed')
else:
reporting.add_test_step("Oneclick restore-{}".format(i), tvaultconf.FAIL)
LOG.debug('Oneclick restore failed')
raise Exception("Oneclick restore failed")
restores[restore_id] = [wid, snapshotid]
restored_vms = self.get_restored_vm_list(restore_id)
vmdetails = {}
restore_details = self.getRestoreDetails(restore_id)['instances']
for arestore in restore_details:
vmdetails[arestore['id']] = arestore['metadata']['instance_id']
LOG.debug("\nRestored vms : {}\n".format(restored_vms))
volumes_parts = ["/dev/vdb", "/dev/vdc", "/dev/vdd"]
mount_points = ["mount_data_a", "mount_data_b", "mount_data_c"]
for rvm in restored_vms:
mdsum = ""
fip = ""
j = 0
rvmvols = self.get_attached_volumes(rvm)
LOG.debug("\nrvmvols : {}\n".format(rvmvols))
if len(rvmvols)>0:
for rvol in rvmvols:
if self.volumes_client.show_volume(rvol)['volume']['bootable'] == 'true':
rvmvols.remove(rvol)
else:
pass
if len(rvmvols)>0:
int_net_name = self.get_net_name(CONF.network.internal_network_id)
fip = self.get_vm_details(rvm)['server']['addresses'][int_net_name][1]['addr']
key = self.get_vm_details(rvm)['server']['key_name']
for rvolume in rvmvols:
LOG.debug("\nrvolume : {} & j {}\n".format(rvolume,j))
ssh = self.SshRemoteMachineConnectionWithRSAKeyName(str(fip), key)
self.execute_command_disk_mount(ssh, str(fip), [volumes_parts[j]], [mount_points[j]])
ssh.close()
mdsum = mdsum + self.calcmd5sum(fip, key, mount_points[j])
j+=1
mdsums_oc[vmdetails[rvm]] = mdsum
else:
pass
LOG.debug("MD5SUMS before restore")
LOG.debug(mdsums_original)
LOG.debug("MD5SUMS after restore")
LOG.debug(mdsums_oc)
if cmp(mdsums_original, mdsums_oc) == 0 :
LOG.debug("***MDSUMS MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.PASS)
status=1
reporting.set_test_script_status(tvaultconf.PASS)
reporting.test_case_to_write()
else:
LOG.debug("***MDSUMS DON'T MATCH***")
reporting.add_test_step("Md5 Verification", tvaultconf.FAIL)
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
except Exception as e:
LOG.error("Exception: " + str(e))
if deleted == 0:
try:
self.delete_vms(vms.keys())
except:
pass
if status !=1:
reporting.set_test_script_status(tvaultconf.FAIL)
reporting.test_case_to_write()
def test_1_tvault1157_1153_1154_1155_wlm_api_restart(self):
reporting.add_test_script(str(__name__))
try:
# Change global job scheduler to disable using API
status = self.disable_global_job_scheduler()
if not status:
reporting.add_test_step("Global job scheduler disable", tvaultconf.PASS)
LOG.debug("Global job scheduler disabled successfully")
else:
reporting.add_test_step("Global job scheduler disable", tvaultconf.FAIL)
raise Exception ("Global job scheduler not disabled")
# Execute wlm-api service restart
status_update = self.restart_wlm_api_service()
if "active (running)" in str(status_update):
reporting.add_test_step("verify wlm-api service is up and running after restart", tvaultconf.PASS)
LOG.debug("wlm-api service is up and running")
else:
reporting.add_test_step("verify wlm-api service is up and running after restart", tvaultconf.FAIL)
raise Exception("wlm-api service is not restarted")
# Verify global job scheduler remains disabled even after wlm-api service restart
status = self.get_global_job_scheduler_status()
if not status:
reporting.add_test_step("Global job scheduler remains disabled after wlm-api service restart", tvaultconf.PASS)
LOG.debug("Global job scheduler remains disabled")
else:
reporting.add_test_step("Global job scheduler remains disabled after wlm-api service restart", tvaultconf.FAIL)
LOG.debug("Global job scheduler changed")
# Change global job scheduler to enable using API
status = self.enable_global_job_scheduler()
if status:
reporting.add_test_step("Global job scheduler enable", tvaultconf.PASS)
LOG.debug("Global job scheduler enabled successfully")
else:
reporting.add_test_step("Global job scheduler enable", tvaultconf.FAIL)
LOG.debug("Global job scheduler not enabled")
# Execute wlm-api service restart
status_update = self.restart_wlm_api_service()
if "active (running)" in str(status_update):
reporting.add_test_step("verify wlm-api service is up and running after restart", tvaultconf.PASS)
LOG.debug("wlm-api service is up and running")
else:
reporting.add_test_step("verify wlm-api service is up and running after restart", tvaultconf.FAIL)
raise Exception("wlm-api service is not restarted")
# Verify global job scheduler remains enabled even after wlm-api service restart
status = self.get_global_job_scheduler_status()
if status:
reporting.add_test_step("Global job scheduler remains enabled after wlm-api service restart", tvaultconf.PASS)
LOG.debug("Global job scheduler remains enabled")
else:
reporting.add_test_step("Global job scheduler remains enabled after wlm-api service restart", tvaultconf.FAIL)
LOG.debug("Global job scheduler changed")
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()
