def env_recover():
test_lib.lib_error_cleanup(test_obj_dict)
for delete_ps in delete_ps_list:
ps_config = test_util.PrimaryStorageOption()
ps_config.set_name(delete_ps.name)
ps_config.set_description(delete_ps.description)
ps_config.set_zone_uuid(delete_ps.zoneUuid)
ps_config.set_type(delete_ps.type)
ps_config.set_url(delete_ps.url)
if delete_ps.type == inventory.LOCAL_STORAGE_TYPE:
new_ps = ps_ops.create_local_primary_storage(ps_config)
elif delete_ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
new_ps = ps_ops.create_nfs_primary_storage(ps_config)
elif delete_ps.type == "SharedBlock":
host = random.choice(res_ops.query_resource(res_ops.HOST))
cmd = "vgchange --lock-start %s && vgremove %s -y" % (
delete_ps.uuid, delete_ps.uuid)
host_username = os.environ.get('hostUsername')
host_password = os.environ.get('hostPassword')
rsp = test_lib.lib_execute_ssh_cmd(host.managementIp,
host_username, host_password,
cmd, 240)
if not rsp:
test_util.test_logger("vgremove failed")
new_ps = ps_ops.create_sharedblock_primary_storage(
ps_config, disk_uuid)
else:
new_ps = None
ps_ops.attach_primary_storage(
new_ps.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
def create_local_ps(vm_ip, zone_uuid, tmp_file):
ps_option = test_util.PrimaryStorageOption()
ps_option.name = 'PS1'
ps_option.url = '/zstack_ps1'
ps_option.zone_uuid = zone_uuid
ps_inv = scen_ops.create_local_primary_storage(vm_ip, ps_option)
return ps_inv
def test():
ps_env = test_stub.PSEnvChecker()
ps1, ps2 = ps_env.get_two_ps()
for _ in xrange(5):
test_util.test_dsc('Remove ps2')
ps_ops.detach_primary_storage(
ps2.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
ps_ops.delete_primary_storage(ps2.uuid)
delete_ps_list.append(ps2)
test_util.test_dsc('Add ps2 back')
ps_config = test_util.PrimaryStorageOption()
ps_config.set_name(ps2.name)
ps_config.set_description(ps2.description)
ps_config.set_zone_uuid(ps2.zoneUuid)
ps_config.set_type(ps2.type)
ps_config.set_url(ps2.url)
if ps2.type == inventory.LOCAL_STORAGE_TYPE:
ps2 = ps_ops.create_local_primary_storage(ps_config)
elif ps2.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps2 = ps_ops.create_nfs_primary_storage(ps_config)
else:
ps2 = None
time.sleep(5)
ps_ops.attach_primary_storage(
ps2.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
time.sleep(5)
delete_ps_list.pop()
test_util.test_dsc('create VM by default para')
vm1 = test_stub.create_multi_vms(name_prefix='vm1',
count=1,
data_volume_number=VOLUME_NUMBER)[0]
test_obj_dict.add_vm(vm1)
if ps_env.is_local_nfs_env:
test_util.test_dsc('create date volume in ps2')
volume = test_stub.create_multi_volumes(count=VOLUME_NUMBER, ps=ps2)
test_obj_dict.add_volume(volume)
else:
test_util.test_dsc('create VM in ps2')
vm2 = test_stub.create_multi_vms(name_prefix='vm2',
count=1,
ps_uuid=ps2.uuid,
data_volume_number=VOLUME_NUMBER)[0]
test_obj_dict.add_vm(vm2)
test_util.test_pass('Multi PrimaryStorage Test Pass')
def env_recover():
test_lib.lib_error_cleanup(test_obj_dict)
for delete_ps in delete_ps_list:
ps_config = test_util.PrimaryStorageOption()
ps_config.set_name(delete_ps.name)
ps_config.set_description(delete_ps.description)
ps_config.set_zone_uuid(delete_ps.zoneUuid)
ps_config.set_type(delete_ps.type)
ps_config.set_url(delete_ps.url)
if delete_ps.type == inventory.LOCAL_STORAGE_TYPE:
new_ps = ps_ops.create_local_primary_storage(ps_config)
elif delete_ps.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
new_ps = ps_ops.create_nfs_primary_storage(ps_config)
else:
new_ps = None
ps_ops.attach_primary_storage(
new_ps.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
def recover_ps():
global ps_inv
ps_config = test_util.PrimaryStorageOption()
ps_config.set_name(ps_inv.name)
ps_config.set_description(ps_inv.description)
ps_config.set_zone_uuid(ps_inv.zoneUuid)
ps_config.set_type(ps_inv.type)
ps_config.set_url(ps_inv.url)
#avoid of ps is already created successfully.
cond = res_ops.gen_query_conditions('zoneUuid', '=', ps_inv.zoneUuid)
cond = res_ops.gen_query_conditions('url', '=', ps_inv.url, cond)
curr_ps = res_ops.query_resource(res_ops.PRIMARY_STORAGE, cond)
if curr_ps:
ps = curr_ps[0]
else:
ps = ps_ops.create_nfs_primary_storage(ps_config)
for cluster_uuid in ps_inv.attachedClusterUuids:
ps_ops.attach_primary_storage(ps.uuid, cluster_uuid)
def test():
global email_endpoint_uuid, email_platform_uuid, my_sns_topic_uuid, host_sns_topic_uuid, ps_uuid, hostname, host_management_ip, host_uuid, host_status, bs_uuid, bs_type, bs_status
bs_cond = res_ops.gen_query_conditions('status', '=', 'Connected')
bs_list = res_ops.query_resource(res_ops.BACKUP_STORAGE, bs_cond)
for bss in bs_list:
if bss.type == res_ops.SFTP_BACKUP_STORAGE:
bs_uuid = bss.uuid
bs_type = bss.type
hostname = bss.hostname
break
elif bss.type == res_ops.IMAGE_STORE_BACKUP_STORAGE:
bs_uuid = bss.uuid
bs_type = bss.type
hostname = bss.hostname
break
else:
test_util.test_skip('No match backupStorage,test skip')
smtp_server = os.environ.get('smtpServer')
pop_server = os.environ.get('popServer')
smtp_port = os.environ.get('smtpPort')
username = os.environ.get('mailUsername')
password = os.environ.get('mailPassword')
email_platform_name = 'Alarm_email'
email_platform = zwt_ops.create_sns_email_platform(smtp_server, smtp_port,
email_platform_name,
username, password)
email_platform_uuid = email_platform.uuid
try:
zwt_ops.validate_sns_email_platform(email_platform_uuid)
except:
test_util.test_fail(
'Validate SNS Email Platform Failed, Email Plarform: %s' %
email_platform_uuid)
email_endpoint_uuid = zwt_ops.create_sns_email_endpoint(
username, 'test_qa', email_platform_uuid).uuid
my_sns_topic = zwt_ops.create_sns_topic('my_sns_topic')
my_sns_topic_uuid = my_sns_topic.uuid
zwt_ops.subscribe_sns_topic(my_sns_topic_uuid, email_endpoint_uuid)
host_sns_topic = zwt_ops.create_sns_topic('host_topic')
host_sns_topic_uuid = host_sns_topic.uuid
zwt_ops.subscribe_sns_topic(host_sns_topic_uuid, email_endpoint_uuid)
ps_actions = [{"actionUuid": my_sns_topic_uuid, "actionType": "sns"}]
ps_namespace = 'ZStack/PrimaryStorage'
ps_disconnected = 'PrimaryStorageDisconnected'
ps_event_sub_uuid = zwt_ops.subscribe_event(ps_namespace, ps_disconnected,
ps_actions).uuid
event_list.append(ps_event_sub_uuid)
bs_actions = [{"actionUuid": my_sns_topic_uuid, "actionType": "sns"}]
bs_namespace = 'ZStack/BackupStorage'
bs_disconnected = 'BackupStorageDisconnected'
bs_event_sub_uuid = zwt_ops.subscribe_event(bs_namespace, bs_disconnected,
bs_actions).uuid
event_list.append(bs_event_sub_uuid)
host_actions = [{"actionUuid": host_sns_topic_uuid, "actionType": "sns"}]
host_namespace = 'ZStack/Host'
host_status_changed = 'HostStatusChanged'
host_status_labels = [{
"key": "NewStatus",
"op": "Equal",
"value": "Disconnected"
}]
host_status_event_sub_uuid = zwt_ops.subscribe_event(
host_namespace, host_status_changed, host_actions,
host_status_labels).uuid
event_list.append(host_status_event_sub_uuid)
host_disconnected = 'HostDisconnected'
host_disconnected_event_sub_uuid = zwt_ops.subscribe_event(
host_namespace, host_disconnected, host_actions).uuid
event_list.append(host_disconnected_event_sub_uuid)
if zwt_ops.check_sns_email(pop_server, username, password, ps_disconnected,
ps_event_sub_uuid):
test_util.test_fail('email already exsist before test')
if zwt_ops.check_sns_email(pop_server, username, password, bs_disconnected,
bs_event_sub_uuid):
test_util.test_fail('email already exsist before test')
if zwt_ops.check_sns_email(pop_server, username, password,
host_status_changed,
host_status_event_sub_uuid):
test_util.test_fail('email already exsist before test')
if zwt_ops.check_sns_email(pop_server, username, password,
host_disconnected,
host_disconnected_event_sub_uuid):
test_util.test_fail('email already exsist before test')
# Disconnected ps ,bs and host
zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid
primary_storage_option = test_util.PrimaryStorageOption()
primary_storage_option.set_type('nfs')
primary_storage_option.set_zone_uuid(zone_uuid)
primary_storage_option.set_name('test_nfs_ps')
primary_storage_option.set_url('222.222.222.222/nfs/')
try:
ps_uuid = ps_ops.create_nfs_primary_storage(
primary_storage_option).uuid
ps_ops.reconnect_primary_storage(ps_uuid)
except:
pass
if bs_type == res_ops.IMAGE_STORE_BACKUP_STORAGE:
bs_ops.update_image_store_backup_storage_info(bs_uuid, 'hostname',
'222.222.222.222')
try:
bs_ops.reconnect_backup_storage(bs_uuid)
except:
cond = res_ops.gen_query_conditions('uuid', '=', bs_uuid)
bs_status = res_ops.query_resource(
res_ops.IMAGE_STORE_BACKUP_STORAGE, cond)[0].status
elif bs_type == res_ops.SFTP_BACKUP_STORAGE:
bs_ops.update_sftp_backup_storage_info(bs_uuid, 'hostname',
'222.222.222.222')
try:
bs_ops.reconnect_backup_storage(bs_uuid)
except:
cond = res_ops.gen_query_conditions('uuid', '=', bs_uuid)
bs_status = res_ops.query_resource(res_ops.SFTP_BACKUP_STORAGE,
cond)[0].status
host_cond = res_ops.gen_query_conditions('status', '=', 'Connected')
host = res_ops.query_resource_with_num(res_ops.HOST,
host_cond,
start=0,
limit=1)[0]
host_uuid = host.uuid
host_management_ip = host.managementIp
host_ops.update_host(host_uuid, 'managementIp', '222.222.222.222')
try:
host_ops.reconnect_host(host_uuid)
except:
cond = res_ops.gen_query_conditions('uuid', '=', host_uuid)
bs_status = res_ops.query_resource(res_ops.HOST, cond)[0].status
# wait for send email
time.sleep(60)
ps_ops.delete_primary_storage(ps_uuid)
if hostname:
if bs_type == res_ops.IMAGE_STORE_BACKUP_STORAGE:
bs_ops.update_image_store_backup_storage_info(
bs_uuid, 'hostname', hostname)
bs_ops.reconnect_backup_storage(bs_uuid)
elif bs_type == res_ops.SFTP_BACKUP_STORAGE:
bs_ops.update_sftp_backup_storage_info(bs_uuid, 'hostname',
hostname)
bs_ops.reconnect_backup_storage(bs_uuid)
host_ops.update_host(host_uuid, 'managementIp', host_management_ip)
host_ops.reconnect_host(host_uuid)
zwt_ops.delete_sns_topic(host_sns_topic_uuid)
zwt_ops.delete_sns_topic(my_sns_topic_uuid)
for event_uuid in event_list:
zwt_ops.unsubscribe_event(event_uuid)
zwt_ops.delete_sns_application_endpoint(email_endpoint_uuid)
zwt_ops.delete_sns_application_platform(email_platform_uuid)
check_1 = zwt_ops.check_sns_email(pop_server, username, password,
ps_disconnected, ps_event_sub_uuid)
check_2 = zwt_ops.check_sns_email(pop_server, username, password,
bs_disconnected, bs_event_sub_uuid)
check_3 = zwt_ops.check_sns_email(pop_server, username, password,
host_status_changed,
host_status_event_sub_uuid)
check_4 = zwt_ops.check_sns_email(pop_server, username, password,
host_disconnected,
host_disconnected_event_sub_uuid)
if check_1 and check_2 and check_3 and check_4:
test_util.test_pass(
'test host ,bs, ps disconnected event with email success!')
else:
test_util.test_fail('cannt receive all event mail')
def test():
ps_env = test_stub.PSEnvChecker()
ps1, ps2 = ps_env.get_two_ps()
if ps2.type == 'SharedBlock':
volumegroup_uuid = ps2.sharedBlocks[0].sharedBlockGroupUuid
disk_uuid.append(ps2.sharedBlocks[0].diskUuid)
for _ in xrange(5):
test_util.test_dsc('Remove ps2')
ps_ops.detach_primary_storage(
ps2.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
ps_ops.delete_primary_storage(ps2.uuid)
delete_ps_list.append(ps2)
test_util.test_dsc('Add ps2 back')
ps_config = test_util.PrimaryStorageOption()
ps_config.set_name(ps2.name)
ps_config.set_description(ps2.description)
ps_config.set_zone_uuid(ps2.zoneUuid)
ps_config.set_type(ps2.type)
ps_config.set_url(ps2.url)
if ps2.type == inventory.LOCAL_STORAGE_TYPE:
ps2 = ps_ops.create_local_primary_storage(ps_config)
elif ps2.type == inventory.NFS_PRIMARY_STORAGE_TYPE:
ps2 = ps_ops.create_nfs_primary_storage(ps_config)
elif ps2.type == "SharedBlock":
host = random.choice(res_ops.query_resource(res_ops.HOST))
cmd = "vgchange --lock-start %s && vgremove %s -y" % (
volumegroup_uuid, volumegroup_uuid)
host_username = os.environ.get('hostUsername')
host_password = os.environ.get('hostPassword')
rsp = test_lib.lib_execute_ssh_cmd(host.managementIp,
host_username, host_password,
cmd, 240)
if not rsp:
cmd = "vgs"
rsp = test_lib.lib_execute_ssh_cmd(host.managementIp,
host_username,
host_password, cmd, 240)
test_util.test_logger(rsp)
test_util.test_fail("vgremove failed")
ps2 = ps_ops.create_sharedblock_primary_storage(
ps_config, disk_uuid)
volumegroup_uuid = ps2.uuid
else:
ps2 = None
time.sleep(5)
ps_ops.attach_primary_storage(
ps2.uuid,
res_ops.get_resource(res_ops.CLUSTER)[0].uuid)
time.sleep(5)
delete_ps_list.pop()
test_util.test_dsc('create VM by default para')
vm1 = test_stub.create_multi_vms(name_prefix='vm1',
count=1,
data_volume_number=VOLUME_NUMBER,
timeout=1200000)[0]
test_obj_dict.add_vm(vm1)
if ps_env.is_local_nfs_env:
test_util.test_dsc('create date volume in ps2')
volume = test_stub.create_multi_volumes(count=VOLUME_NUMBER, ps=ps2)
test_obj_dict.add_volume(volume)
else:
test_util.test_dsc('create VM in ps2')
vm2 = test_stub.create_multi_vms(name_prefix='vm2',
count=1,
ps_uuid=ps2.uuid,
data_volume_number=VOLUME_NUMBER,
timeout=1200000)[0]
test_obj_dict.add_vm(vm2)
test_util.test_pass('Multi PrimaryStorage Test Pass')