def test():
os.environ['ZSTACK_THREAD_THRESHOLD'] = '1000'
os.environ['ZSTACK_TEST_NUM'] = '1000'
test_lib.lib_set_provision_memory_rate(20)
test_lib.lib_set_provision_storage_rate(20)
lib_set_provision_cpu_rate(20)
Create()
time.sleep(180)
create_vm_begin_time = get_begin_time()
create_vm_end_time = get_end_time()
print("begin time = %s") % create_vm_begin_time
print("end time = %s") % create_vm_end_time
if create_vm_end_time != 0 and create_vm_begin_time != 0:
create_1000_vm_time = create_vm_end_time - create_vm_begin_time
test_util.test_dsc("create_vm_time is " + str(create_1000_vm_time))
Destroy_VM()
time.sleep(180)
Expunge_VM()
time.sleep(180)
zone_name = os.environ.get('zoneName')
zone = res_ops.get_resource(res_ops.ZONE, name=zone_name)[0]
zone_ops.delete_zone(zone.uuid)
test_util.test_pass('Create 1000 vms success,takes %s time' %
create_1000_vm_time)
def test():
os.environ['ZSTACK_THREAD_THRESHOLD']='1000'
os.environ['ZSTACK_TEST_NUM']='1000'
test_lib.lib_set_provision_memory_rate(20)
test_lib.lib_set_provision_storage_rate(20)
lib_set_provision_cpu_rate(20)
Create()
time.sleep(180)
create_vm_begin_time = get_begin_time()
create_vm_end_time = get_end_time()
print ("begin time = %s") % create_vm_begin_time
print ("end time = %s") % create_vm_end_time
if create_vm_end_time != 0 and create_vm_begin_time != 0:
create_1000_vm_time = create_vm_end_time - create_vm_begin_time
test_util.test_dsc("create_vm_time is "+str(create_1000_vm_time))
Destroy_VM()
time.sleep(180)
Expunge_VM()
time.sleep(180)
zone_name = os.environ.get('zoneName')
zone = res_ops.get_resource(res_ops.ZONE, name = zone_name)[0]
zone_ops.delete_zone(zone.uuid)
test_util.test_pass('Create 1000 vms success,takes %s time' % create_1000_vm_time)
def test():
test_stub.reload_default_license()
test_util.test_logger('Check default community license')
test_stub.check_license(None, None, 2147483647, False, 'Community')
test_util.test_logger('Load and Check TrialExt license with 10 day and 3 CPU')
file_path = test_stub.gen_license('woodpecker', '*****@*****.**', '10', 'Prepaid', '3', '')
test_stub.load_license(file_path)
issued_date = test_stub.get_license_info().issuedDate
expired_date = test_stub.license_date_cal(issued_date, 86400 * 10)
test_stub.check_license("*****@*****.**", 3, None, False, 'Paid', issued_date=issued_date, expired_date=expired_date)
# add the vcenter 1.203
test_stub.create_zone()
username = os.environ.get("vcenteruser")
password = os.environ.get("vcenterpwd")
zone_name = "ZONE1"
conditions = res_ops.gen_query_conditions('name', '=', zone_name)
zone_uuid = res_ops.query_resource(res_ops.ZONE, conditions)[0].uuid
https = "true"
vcenterdomain = "172.20.0.50"
vct_ops.add_vcenter("vcenter_test", vcenterdomain, username, password, https, zone_uuid)
vcenter_uuid = res_ops.get_resource(res_ops.VCENTER)[0].uuid
time.sleep(5)
vct_ops.delete_vcenter(vcenter_uuid)
time.sleep(5)
zone_ops.delete_zone(zone_uuid)
test_util.test_pass('Check License and add the vcenter Test Success')
def destroy_initial_database():
zoneinvs = res_ops.query_resource_fields(res_ops.ZONE, [], None, ['uuid'])
for zoneinv in zoneinvs:
zone_operations.delete_zone(zoneinv.uuid)
backstorageinvs = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [], None, ['uuid'])
for backstorageinv in backstorageinvs:
bs_operations.delete_backup_storage(backstorageinv.uuid)
iam2_ops.clean_iam2_enviroment()
def destroy_initial_database():
zoneinvs = res_ops.query_resource_fields(res_ops.ZONE, [], None, ['uuid'])
for zoneinv in zoneinvs:
zone_operations.delete_zone(zoneinv.uuid)
backstorageinvs = res_ops.query_resource_fields(res_ops.BACKUP_STORAGE, [],
None, ['uuid'])
for backstorageinv in backstorageinvs:
bs_operations.delete_backup_storage(backstorageinv.uuid)
def test():
test_stub.reload_default_license()
test_util.test_logger('Check default community license')
test_stub.check_license(None, None, 2147483647, False, 'Community')
test_util.test_logger('Load and Check TrialExt license with 10 day and 1 CPU')
file_path = test_stub.gen_license('woodpecker', '*****@*****.**', '10', 'Prepaid', '1', '')
test_stub.load_license(file_path)
issued_date = test_stub.get_license_info().issuedDate
expired_date = test_stub.license_date_cal(issued_date, 86400 * 10)
test_stub.check_license("*****@*****.**", 1, None, False, 'Paid', issued_date=issued_date, expired_date=expired_date)
# add the vcenter 1.50
test_stub.create_zone()
username = os.environ.get("vcenteruser")
password = os.environ.get("vcenterpwd")
zone_name = "ZONE1"
conditions = res_ops.gen_query_conditions('name', '=', zone_name)
zone_uuid = res_ops.query_resource(res_ops.ZONE, conditions)[0].uuid
https = "true"
vcenterdomain = "172.20.0.50"
try:
vct_ops.add_vcenter("vcenter_test", vcenterdomain, username, password, https, zone_uuid)
test_util.test_fail('vCenter can not add success')
except Exception:
pass
test_util.test_logger('load and check addon license vmware with 2 day and 1 CPU ')
file_path = test_stub.gen_addons_license('woodpecker', '*****@*****.**', '2', 'Addon', '1', '', 'vmware')
node_uuid = res_ops.query_resource(res_ops.MANAGEMENT_NODE)[0].uuid
test_stub.update_license(node_uuid, file_path)
issued_date = test_stub.get_license_addons_info().issuedDate
expired_date = test_stub.license_date_cal(issued_date, 86400 * 2)
test_stub.check_license_addons(1, None, False, 'AddOn', issued_date=issued_date, expired_date=expired_date)
vct_ops.add_vcenter("vcenter_test", vcenterdomain, username, password, https, zone_uuid)
vcenter_uuid = res_ops.get_resource(res_ops.VCENTER)[0].uuid
# sync vcenter
time.sleep(10)
vct_ops.sync_vcenter(vcenter_uuid)
time.sleep(15)
vct_ops.delete_vcenter(vcenter_uuid)
time.sleep(5)
zone_ops.delete_zone(zone_uuid)
test_util.test_logger('start to delete the addons vmware license')
uuid = test_stub.get_license_addons_info().uuid
lic_ops.delete_license(node_uuid, uuid)
test_util.test_logger('delete the addons license [uuid:] %s' % uuid)
test_util.test_pass('Check License and add the vcenter and check sync Test Success')
def delete_zones():
zones = res_ops.query_resource(res_ops.ZONE, [])
for zone in zones:
zone_ops.delete_zone(zone.uuid)
def delete_zones():
zones = res_ops.query_resource(res_ops.ZONE, [])
for zone in zones:
zone_ops.delete_zone(zone.uuid)
def test():
test_util.test_dsc('Create Scheduler Trigger and Scheduler Job')
cond = res_ops.gen_query_conditions('type', '=', 'ImageStoreBackupStorage')
bs = res_ops.query_resource(res_ops.BACKUP_STORAGE, cond)
if not bs :
test_util.test_skip('Not find image store type backup storage.')
image_name = os.environ.get('imageName_net')
l3_name = os.environ.get('l3PublicNetworkName')
remote_bs_vm = test_stub.create_vm('remote_bs_vm', image_name, l3_name)
test_obj_dict.add_vm(remote_bs_vm)
image_name = os.environ.get('imageName_s')
l3_name = os.environ.get('l3VlanNetworkName1')
test_vm = test_stub.create_vm('test-vm', image_name, l3_name)
test_obj_dict.add_vm(test_vm)
add_local_bs_tag = tag_ops.create_system_tag('ImageStoreBackupStorageVO', bs[0].uuid,'allowbackup')
#wait for vm start up
test_lib.lib_wait_target_up(remote_bs_vm.vm.vmNics[0].ip, '22', 90)
remote_bs = test_stub.create_image_store_backup_storage('remote_bs', remote_bs_vm.vm.vmNics[0].ip, 'root', 'password', '/zstack_bs', '22')
add_remote_bs = tag_ops.create_system_tag('ImageStoreBackupStorageVO', remote_bs.uuid,'remotebackup')
zone_uuid = res_ops.query_resource(res_ops.ZONE)[0].uuid
bs_ops.attach_backup_storage(remote_bs.uuid, zone_uuid)
parameters= {"retentionType":"Count","retentionValue":"1","backupStorageUuids":bs[0].uuid,"remoteBackupStorageUuid":""}
schd_job = schd_ops.create_scheduler_job('backup_database_scheduler', 'backup_database_scheduler', '7ae6456c0b01324dae6d4bef358a5772', 'databaseBackup',parameters=parameters)
schd_trigger = schd_ops.create_scheduler_trigger('backup_database_schedule',type='cron', cron='0 * * ? * *')
schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid)
#wait for 60s *2
time.sleep(120)
db_backup1 = schd_ops.query_db_backup()
if len(db_backup1) != 1:
test_util.test_fail('there sholuld be 1 db backup,but now there are %s' % len(db_backup1))
db_backup2 = schd_ops.get_db_backup_from_imagestore(url = 'ssh://*****:*****@%s:22/zstack_bs' % bs[0].hostname)
if len(db_backup2.backups) != 1:
test_util.test_fail('there sholuld be 1 db backup,but now there are %s' % len(db_backup2.backups))
db_url = schd_ops.export_db_backup_from_bs(bs[0].uuid, db_backup1[0].uuid)
test_util.test_dsc('export database backup successfully,url is %s' % db_url.databaseBackupUrl)
schd_ops.sync_db_from_imagestore_bs(remote_bs.uuid, bs[0].uuid, db_backup1[0].uuid)
test_vm.destroy()
test_util.test_dsc('Recover db From BackupStorage')
backupStorageUrl = 'ssh://*****:*****@%s:22/zstack_bs' % remote_bs_vm.vm.vmNics[0].ip
recover_db = schd_ops.recover_db_from_backup(backupStorageUrl = backupStorageUrl, backupInstallPath = db_backup2.backups[0].installPath, mysqlRootPassword='******')
#wait for db recover
time.sleep(60)
cond = res_ops.gen_query_conditions('name', '=', 'test-vm')
vm = res_ops.query_resource(res_ops.VM_INSTANCE, cond)
if not vm:
test_util.test_fail('there sholuld be a vm after recovering db from remote backup bs')
schd_ops.change_scheduler_state(schd_job.uuid, 'disable')
db_backup3 = schd_ops.query_db_backup()
zone = res_ops.query_resource(res_ops.ZONE)[0]
zone_ops.delete_zone(zone.uuid)
recover_db = schd_ops.recover_db_from_backup(uuid=db_backup3[0].uuid, mysqlRootPassword='******')
#wait for db recover
time.sleep(60)
vm = res_ops.query_resource(res_ops.VM_INSTANCE, cond)
if not vm:
test_util.test_fail('there sholuld be a vm after recovering db from local backup bs')
test_util.test_dsc('Clear env')
schd_ops.del_scheduler_job(schd_job.uuid)
schd_ops.del_scheduler_trigger(schd_trigger.uuid)
tag_ops.delete_tag(add_local_bs_tag.uuid)
bs_ops.delete_backup_storage(remote_bs.uuid)
bs_ops.reclaim_space_from_bs(bs[0].uuid)
remote_bs_vm.destroy()
test_vm.destroy()
def test():
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
global curr_deploy_conf
curr_deploy_conf = exp_ops.export_zstack_deployment_config(
test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_s')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up zone1
zone1 = res_ops.get_resource(res_ops.ZONE, name=zone1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING,
conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_zone_uuid(zone1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
zone_ops.delete_zone(zone1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
zone_ops.add_zone_resource(curr_deploy_conf, zone1_name)
zone1 = res_ops.get_resource(res_ops.ZONE, name=zone1_name)[0]
vm_creation_option.set_zone_uuid(zone1.uuid)
vm_creation_option.set_l3_uuids([])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_lib.lib_robot_status_check(test_obj_dict)
#time.sleep(5)
#vm.check()
#vm.destroy()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Zone Test Success')
def test():
#This conf should only be put in test(), since test_lib.deploy_config
# should be set by woodpecker.
global curr_deploy_conf
curr_deploy_conf = exp_ops.export_zstack_deployment_config(test_lib.deploy_config)
vm_creation_option = test_util.VmOption()
image_name = os.environ.get('imageName_net')
image_uuid = test_lib.lib_get_image_by_name(image_name).uuid
#pick up zone1
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
conditions = res_ops.gen_query_conditions('type', '=', 'UserVm')
instance_offering_uuid = res_ops.query_resource(res_ops.INSTANCE_OFFERING, conditions)[0].uuid
vm_creation_option.set_image_uuid(image_uuid)
vm_creation_option.set_instance_offering_uuid(instance_offering_uuid)
vm_creation_option.set_name('multizones_basic_vm')
vm_creation_option.set_zone_uuid(zone1.uuid)
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
zone_ops.delete_zone(zone1.uuid)
test_obj_dict.mv_vm(vm1, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm2, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm3, vm_header.RUNNING, vm_header.DESTROYED)
test_obj_dict.mv_vm(vm4, vm_header.RUNNING, vm_header.DESTROYED)
vm1.update()
vm2.update()
vm3.update()
vm4.update()
test_lib.lib_robot_status_check(test_obj_dict)
zone_ops.add_zone_resource(curr_deploy_conf, zone1_name)
zone1 = res_ops.get_resource(res_ops.ZONE, name = zone1_name)[0]
vm_creation_option.set_zone_uuid(zone1.uuid)
vm_creation_option.set_l3_uuids([])
vm1 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm1)
vm2 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm2)
vm3 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm3)
vm4 = test_lib.lib_create_vm(vm_creation_option)
test_obj_dict.add_vm(vm4)
test_lib.lib_robot_status_check(test_obj_dict)
#time.sleep(5)
#vm.check()
#vm.destroy()
test_lib.lib_robot_cleanup(test_obj_dict)
test_util.test_pass('Delete Zone Test Success')
def test():
global new_zone_uuid
iam2_ops.clean_iam2_enviroment()
# 1 create new zone
new_zone_uuid = test_stub.create_zone().uuid
# 2 create platform admin related new zone
platform_admin_name = 'platformadmin'
password = \
'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86'
platform_admin_uuid = iam2_ops.create_iam2_virtual_id(platform_admin_name, password).uuid
attributes = [{"name": "__PlatformAdmin__"}, {"name": "__PlatformAdminRelatedZone__", "value": new_zone_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(platform_admin_uuid, attributes)
# 3 create project
project_name = 'test_project'
project = iam2_ops.create_iam2_project(project_name)
project_uuid = project.uuid
linked_account_uuid = project.linkedAccountUuid
attributes = [{"name": "__ProjectRelatedZone__", "value": new_zone_uuid}]
iam2_ops.add_attributes_to_iam2_project(project_uuid, attributes)
# 4 create projectAdmin and virtual id into project
project_admin_name = 'projectadmin'
project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, password).uuid
iam2_ops.add_iam2_virtual_ids_to_project([project_admin_uuid], project_uuid)
attributes = [{"name": "__ProjectAdmin__", "value": project_uuid}]
iam2_ops.add_attributes_to_iam2_virtual_id(project_admin_uuid, attributes)
username = '******'
virtual_id_uuid = iam2_ops.create_iam2_virtual_id(username, password).uuid
iam2_ops.add_iam2_virtual_ids_to_project([virtual_id_uuid], project_uuid)
action = "org.zstack.ticket.**"
statements = [{"effect": "Allow", "actions": [action]}]
role_uuid = iam2_ops.create_role('test_role', statements).uuid
iam2_ops.add_policy_statements_to_role(role_uuid, statements)
statement_uuid = iam2_ops.get_policy_statement_uuid_of_role(role_uuid, action)
iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], virtual_id_uuid)
virtual_id_session = iam2_ops.login_iam2_virtual_id(username, password)
virtual_id_session = iam2_ops.login_iam2_project(project_name, virtual_id_session).uuid
# 5 create ticket
ticket = test_stub.create_vm_ticket(virtual_id_uuid, project_uuid, virtual_id_session)
ticket_02 = test_stub.create_vm_ticket(virtual_id_uuid, project_uuid, virtual_id_session, name='new ticket',
request_name='ticket-vm-2')
acc_ops.logout(virtual_id_session)
ticket_ops.change_ticket_status(ticket.uuid, 'reject')
# 6 delete Zone
zone_ops.delete_zone(new_zone_uuid)
# 7 cascade test
# test for platformAdmin
cond = res_ops.gen_query_conditions('virtualIDUuid', '=', platform_admin_uuid)
cond_02 = res_ops.gen_query_conditions('name', '=', "__PlatformAdminRelatedZone__", cond)
attributes = res_ops.query_resource(res_ops.IAM2_VIRTUAL_ID_ATTRIBUTE, cond_02)
if attributes:
test_util.test_fail('the attributes:uuid[%s] name[%s] is still exist after delete the new zone[%s]' % (
attributes[0].uuid, attributes[0].name, new_zone_uuid))
# test for project
cond = res_ops.gen_query_conditions('uuid', '=', project_uuid)
project_inv = res_ops.query_resource(res_ops.IAM2_PROJECT, cond)
if project_inv:
test_util.test_fail(
'the project[%s] is still exist after delete the new zone[%s]' % (project_inv[0].uuid, new_zone_uuid))
cond = res_ops.gen_query_conditions('virtualIDUuid', '=', project_admin_uuid)
cond_02 = res_ops.gen_query_conditions('name', '=', "__ProjectAdmin__", cond)
attributes = res_ops.query_resource(res_ops.IAM2_VIRTUAL_ID_ATTRIBUTE, cond_02)
if attributes:
test_util.test_fail('the attributes:uuid[%s] name[%s] is still exist after delete the new zone[%s]' % (
attributes[0].uuid, attributes[0].name, new_zone_uuid))
platform_admin_session = iam2_ops.login_iam2_virtual_id(platform_admin_name, password)
project_admin_session = iam2_ops.login_iam2_virtual_id(project_admin_name, password)
virtual_id_session = iam2_ops.login_iam2_virtual_id(username, password)
try:
iam2_ops.login_iam2_project(project_name, project_admin_session)
test_util.test_fail("can't login deleted project ,fail!")
except:
test_util.test_logger("can't login deleted project ,success!")
try:
iam2_ops.login_iam2_project(project_name, virtual_id_session)
test_util.test_fail("can't login deleted project ,fail!")
except:
test_util.test_logger("can't login deleted project ,success!")
# test for ticket
cond = res_ops.gen_query_conditions('uuid', '=', ticket.uuid)
ticket_inv = res_ops.query_resource(res_ops.TICKET, cond)
if ticket_inv:
test_util.test_fail(
"Ticket [%s] is still exist after delete the zone[%s]" % (ticket_inv[0].uuid, new_zone_uuid))
cond = res_ops.gen_query_conditions('uuid', '=', ticket_02.uuid)
ticket_02_inv = res_ops.query_resource(res_ops.TICKET, cond)
if ticket_02_inv:
test_util.test_fail(
"Ticket [%s] is still exist after delete the zone[%s]" % (ticket_02_inv[0].uuid, new_zone_uuid))
iam2_ops.clean_iam2_enviroment()
test_util.test_pass("success test project retired")
def error_cleanup():
global new_zone_uuid
if new_zone_uuid:
zone_ops.delete_zone(new_zone_uuid)
iam2_ops.clean_iam2_enviroment()
