def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+60, 120) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 120, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+120, 120) test_stub.sleep_util(start_date + 58) vm.update() if not test_lib.lib_is_vm_running(vm.get_vm()): test_util.test_fail( 'VM is expected to run until stop vm scheduler start_date') for i in range(0, 10): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120 * i + 5) test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 60 + 120 * i + 5)) vm.update() if vm.get_vm().state != 'Stopping' and vm.get_vm().state != 'Stopped': test_util.test_fail('VM is expected to stop') test_stub.sleep_util(start_date + 60 + 120 * i + 65) test_util.test_logger( 'check VM status at %s, VM is expected to start' % (start_date + 60 + 120 * i + 65)) vm.update() if vm.get_vm().state != 'Starting' and vm.get_vm().state != 'Running': test_util.test_fail('VM is expected to start') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.destroy() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 global new_account vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+30, None, 60, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+30, 60) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+60, None, 60, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+60, 60) test_stub.sleep_util(start_date+130) test_util.test_dsc('check scheduler state after creating scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', start_date+30): test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', start_date+60): test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range') # vm.check(); new_account = account_operations.create_account('new_account', 'password', 'Normal') res_ops.change_recource_owner(new_account.uuid, vm.vm.uuid) current_time = int(time.time()) except_start_time = start_date + 60 * (((current_time - start_date) % 60) + 1) test_stub.sleep_util(except_start_time + 130) test_util.test_dsc('check scheduler state after changing the owner of vm') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') if check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+30): test_util.test_fail('StopVmInstanceJob executed at unexpected timestamp range') if check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+60): test_util.test_fail('StartVmInstanceJob executed at unexpected timestamp range') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.destroy() account_operations.delete_account(new_account.uuid) test_util.test_pass('Check Scheduler State after Changing VM Owner Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+60, 3, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+60, 120, 3) # if schd1.stopTime != start_date + 60 + 120 * 3: # test_util.test_fail('[scheduler:] %s is expected have stopTime as %s' % (schd1.uuid, start_date + 60 + 120 * 3)) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+120, 2, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+120, 120, 2) # if schd2.stopTime != start_date + 120 + 120 * 2: # test_util.test_fail('[scheduler:] %s is expected have stopTime as %s' % (schd2.uuid, start_date + 120 + 120 * 2)) test_stub.sleep_util(start_date+58) vm.update() if not test_lib.lib_is_vm_running(vm.get_vm()): test_util.test_fail('VM is expected to run until stop vm scheduler start_date') for i in range(0, 5): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120*i + 5) test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 60 + 120*i + 5)) vm.update() if vm.get_vm().state != 'Stopping' and vm.get_vm().state != 'Stopped': test_util.test_fail('VM is expected to stop') test_stub.sleep_util(start_date + 60 + 120*i + 65) if i >= 2: test_util.test_logger('check VM status at %s, VM is expected to stay stopped' % (start_date + 60 + 120*i + 65)) vm.update() if vm.get_vm().state != 'Stopped': test_util.test_fail('VM is expected to stay stop') continue test_util.test_logger('check VM status at %s, VM is expected to start' % (start_date + 60 + 120*i + 65)) vm.update() if vm.get_vm().state != 'Starting' and vm.get_vm().state != 'Running': test_util.test_fail('VM is expected to start') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.destroy() test_util.test_pass('Create Simple VM Stop Start Scheduler Repeat Count Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+60, 120) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 120, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+120, 120) test_stub.sleep_util(start_date + 60 + 120 * 2 + 5) schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) time.sleep(60) vm.update() vm_state = vm.get_vm().state for i in range(3, 5): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120 * i + 5) vm.update() test_util.test_logger( 'check VM status at %s, VM is expected to stay in state %s' % (start_date + 60 + 120 * i + 5, vm_state)) if vm.get_vm().state != vm_state: test_util.test_fail('VM is expected to stay in state %s' % (vm_state)) vm.destroy() schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global vm global schd_job global schd_trigger vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm.check() start_date = int(time.time()) schd_job = schd_ops.create_scheduler_job('simple_reboot_vm_scheduler', 'simple_reboot_vm_scheduler', vm.get_vm().uuid, 'rebootVm', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_reboot_vm_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) #schd = vm_ops.reboot_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_reboot_vm_scheduler', start_date+60, 120) test_stub.sleep_util(start_date+58) if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 120): test_util.test_fail('VM: %s is not reboot in 120 seconds. Fail to reboot it with scheduler. ' % vm.get_vm().uuid) for i in range(0, 58): if test_lib.lib_find_in_local_management_server_log(start_date+i, '[msg received]: org.zstack.header.vm.RebootVmInstanceMsg {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' (start_date+60)) test_stub.sleep_util(start_date+59) if not test_lib.lib_find_in_local_management_server_log(start_date+60, '[msg received]: org.zstack.header.vm.RebootVmInstanceMsg {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' % (start_date+60)) schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() test_util.test_pass('Create Simple VM Reboot Scheduler Success')
def test(): global vm global schd_job global schd_trigger vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm.check() start_date = int(time.time()) schd_job = schd_ops.create_scheduler_job('simple_reboot_vm_scheduler', 'simple_reboot_vm_scheduler', vm.get_vm().uuid, 'rebootVm', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_reboot_vm_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) #schd = vm_ops.reboot_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_reboot_vm_scheduler', start_date+60, 120) test_stub.sleep_util(start_date+58) if not test_lib.lib_wait_target_down(vm.get_vm().vmNics[0].ip, '22', 120): test_util.test_fail('VM: %s is not reboot in 120 seconds. Fail to reboot it with scheduler. ' % vm.get_vm().uuid) for i in range(0, 58): if test_lib.lib_find_in_local_management_server_log(start_date+i, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' (start_date+60)) test_stub.sleep_util(start_date+59) if not test_lib.lib_find_in_local_management_server_log(start_date+60, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' % (start_date+60)) schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() test_util.test_pass('Create Simple VM Reboot Scheduler Success')
def create_start_vm_scheduler(vm_uuid, start_date, ops_id): global schd_jobs global schd_triggers schd_job = schd_ops.create_scheduler_job('simple_start_vm_scheduler_%s' % (ops_id), 'simple_stop_vm_scheduler', vm_uuid, 'startVm', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+300, None, 1000, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) schd_jobs.append(schd_job) schd_triggers.append(schd_trigger)
def create_start_vm_scheduler(vm_uuid, start_date, ops_id): global schd_jobs global schd_triggers schd_job = schd_ops.create_scheduler_job('simple_start_vm_scheduler_%s' % (ops_id), 'simple_stop_vm_scheduler', vm_uuid, 'startVm', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+100+ops_id, None, 1000, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) schd_jobs.append(schd_job) schd_triggers.append(schd_trigger)
def test(): global vm global schd_job global schd_trigger vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) conditions = res_ops.gen_query_conditions('type', '=', 'Ceph') pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE, conditions) if len(pss) == 0: test_util.test_skip('Skip due to no ceph storage available') disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot scheduler testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) volume.detach() test_util.test_dsc('create snapshot and check') start_date = int(time.time()) parameters = {"snapshotMaxNumber": "3"} schd_job = schd_ops.create_scheduler_job('simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.get_volume().uuid, 'volumeSnapshot', parameters) schd_trigger = schd_ops.create_scheduler_trigger('simple_create_snapshot_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120*i - 2) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(start_date + 60 + 120*i + 65) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i + 65, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) test_stub.sleep_util(start_date + 60 + 120*3 +65) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i + 65, 3)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if new_snapshot_num != 3: test_util.test_fail('there sholuld be 3 snapshots') schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() test_util.test_pass('Create limit create volume snapshot num success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+60, 120) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+120, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+120, 120) test_stub.sleep_util(start_date + 60 + 120*2 + 5) schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) time.sleep(60) vm.update() vm_state = vm.get_vm().state for i in range(3, 5): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120*i + 5) vm.update() test_util.test_logger('check VM status at %s, VM is expected to stay in state %s' % (start_date + 60 + 120*i + 5, vm_state)) if vm.get_vm().state != vm_state: test_util.test_fail('VM is expected to stay in state %s' % (vm_state)) vm.destroy() schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global vm global schd_job global schd_trigger vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot scheduler testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) volume.detach() test_util.test_dsc('create snapshot and check') start_date = int(time.time()) #sp_option = test_util.SnapshotOption() #sp_option.set_name('simple_schduler_snapshot') #sp_option.set_volume_uuid(volume.get_volume().uuid) schd_job = schd_ops.create_scheduler_job('simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.get_volume().uuid, 'volumeSnapshot', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_create_snapshot_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) #schd = vol_ops.create_snapshot_scheduler(sp_option, 'simple', 'simple_create_snapshot_scheduler', start_date+60, 120) snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120*i - 2) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(start_date + 60 + 120*i + 65) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i + 65, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
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(): global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid flavor = case_flavor[os.environ.get('CASE_FLAVOR')] # 1 create project project_name = 'test_project' project = iam2_ops.create_iam2_project(project_name) project_uuid = project.uuid project_linked_account_uuid = project.linkedAccountUuid if flavor['target_role'] == 'project_admin': # 2 create virtual id project_admin_name = 'username' project_admin_password = '******' project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid # 3 create project admin 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) # login in project by project admin project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password) project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid # iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes) elif flavor['target_role'] == 'project_operator': project_operator_name = 'username2' project_operator_password = '******' attributes = [{"name": "__ProjectOperator__", "value": project_uuid}] project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid # login in project by project operator iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid) project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password) project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid elif flavor['target_role'] == 'project_member': plain_user_name = 'username' plain_user_password = '******' plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password, project_uuid=project_uuid).uuid # 3 add virtual id to project iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid) # 4 login in project by plain user plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password) # 4 login in project #project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid) project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid # Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge if flavor['target_role'] == 'project_member': statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}, {"effect": "Allow", "actions": ["org.zstack.scheduler.**"]}] role_uuid = iam2_ops.create_role('test_role', statements).uuid iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid) vm_creation_option = test_util.VmOption() l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid]) vm_creation_option.set_l3_uuids([l3_net_uuid]) image_uuid = test_lib.lib_get_image_by_name("centos").uuid vm_creation_option.set_image_uuid(image_uuid) acc_ops.share_resources([project_linked_account_uuid], [image_uuid]) instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid]) vm_creation_option.set_name('vm_for_project_management') vm_creation_option.set_session_uuid(project_login_uuid) vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid) # scheduler ops: start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None, session_uuid=project_login_uuid) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+5, None, 15, 'simple', session_uuid=project_login_uuid) schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.change_scheduler_state(schd_job1.uuid, 'disable', session_uuid=project_login_uuid) schd_ops.change_scheduler_state(schd_job1.uuid, 'enable', session_uuid=project_login_uuid) schd_ops.remove_scheduler_job_from_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.del_scheduler_job(schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid, session_uuid=project_login_uuid) schd_ops.get_current_time() vm_ops.destroy_vm(vm.get_vm().uuid, session_uuid=project_login_uuid) vm_ops.expunge_vm(vm.get_vm().uuid, session_uuid=project_login_uuid) # 11 delete acc_ops.logout(project_login_uuid) if virtual_id_uuid != None: iam2_ops.delete_iam2_virtual_id(virtual_id_uuid) if project_admin_uuid != None: iam2_ops.delete_iam2_virtual_id(project_admin_uuid) if project_operator_uuid != None: iam2_ops.delete_iam2_virtual_id(project_operator_uuid) if plain_user_uuid != None: iam2_ops.delete_iam2_virtual_id(plain_user_uuid) iam2_ops.delete_iam2_project(project_uuid) iam2_ops.expunge_iam2_project(project_uuid) test_util.test_pass('success test iam2 login in by project admin!')
def test(): imagestore = test_lib.lib_get_image_store_backup_storage() if imagestore == None: test_util.test_skip('Required imagestore to test') image_uuid = test_stub.get_image_by_bs(imagestore.uuid) pss = res_ops.query_resource(res_ops.PRIMARY_STORAGE) ps_uuid = pss[0].uuid vmBackup = 'vmBackup' volumeBackup = 'volumeBackup' parameters = {'retentionType': 'Count', 'retentionValue': '10', 'backupStorageUuids': imagestore.uuid, 'remoteBackupStorageUuid': '', 'networkWriteBandwidth': '', 'networkReadBandwidth': '', 'volumeReadBandwidth': '', 'volumeWriteBandwidth': ''} test_util.test_logger(parameters) vm1 = test_stub.create_vm(image_uuid=image_uuid, ps_uuid=ps_uuid) vm1_uuid = vm1.get_vm().uuid volume1 = test_stub.create_volume() vol1_uuid = volume1.get_volume().uuid test_lib.lib_attach_volume(vol1_uuid, vm1_uuid) job1 = sch_ops.create_scheduler_job(name='vm1', description='vm1 with volume backup', target_uuid=vm1_uuid, type=vmBackup, parameters=parameters) vm2 = test_stub.create_vm(image_uuid=image_uuid, ps_uuid=ps_uuid) vm2_uuid = vm2.get_vm().uuid volume2 = test_stub.create_volume() vol2_uuid = volume2.get_volume().uuid test_lib.lib_attach_volume(vol2_uuid, vm2_uuid) job2 = sch_ops.create_scheduler_job(name='vm2-root', description='vm2 root volume backup', target_uuid=vm2.get_vm().allVolumes[0].uuid, type=volumeBackup, parameters=parameters) name1 = 'job_group_1' job_group_1 = sch_ops.create_scheduler_job_group(name=name1, description='vmbackup', type=vmBackup, parameters=parameters) sch_ops.add_jobs_to_job_group([job1.uuid], job_group_1.uuid) name2 = 'job_group_2' job_group_2 = sch_ops.create_scheduler_job_group(name=name2, description='volumebackup', type=volumeBackup, parameters=parameters) sch_ops.add_jobs_to_job_group([job2.uuid], job_group_2.uuid) trigger = sch_ops.create_scheduler_trigger('10sec', start_time = int(time.time()+5), type = 'cron', cron = '0/10 * * * * ?') sch_ops.add_scheduler_job_group_to_trigger(trigger.uuid, job_group_1.uuid, triggerNow=True) sch_ops.add_scheduler_job_group_to_trigger(trigger.uuid, job_group_2.uuid, triggerNow=False) time.sleep(9) # check # vm1/vol1 backups.lenth == 2 # vm2 backups.lenth == 1 cond = res_ops.gen_query_conditions('volumeUuid', '=', vm1.get_vm().allVolumes[0].uuid) backups = res_ops.query_resource(res_ops.VOLUME_BACKUP, cond) assert len(backups) == 2 cond = res_ops.gen_query_conditions('volumeUuid', '=', volume1.get_volume().uuid) backups = res_ops.query_resource(res_ops.VOLUME_BACKUP, cond) assert len(backups) == 2 cond = res_ops.gen_query_conditions('volumeUuid', '=', vm1.get_vm().allVolumes[0].uuid) backups = res_ops.query_resource(res_ops.VOLUME_BACKUP, cond) assert len(backups) == 1 cond = res_ops.gen_query_conditions('volumeUuid', '=', volume1.get_volume().uuid) backups = res_ops.query_resource(res_ops.VOLUME_BACKUP, cond) assert len(backups) == 0 sch_ops.remove_scheduler_job_from_trigger(trigger.uuid, job_group_1.uuid) # sch_ops.remove_scheduler_job_from_trigger(trigger.uuid, job_group_2.uuid) cond = res_ops.gen_query_conditions('uuid', '=', job_group_1.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 0 sch_ops.del_scheduler_trigger(trigger.uuid) cond = res_ops.gen_query_conditions('uuid', '=', trigger.uuid) trigger_inv = res_ops.query_resource(res_ops.SCHEDULERTRIGGER, cond) cond = res_ops.gen_query_conditions('uuid', '=', job_group_2.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 0 assert len(trigger_inv) == 0 sch_ops.remove_jobs_from_job_group([job1.uuid], job_group_1.uuid) cond = res_ops.gen_query_conditions('uuid', '=', job_group_1.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 0 sch_ops.del_scheduler_job_group(job_group_2.uuid) cond = res_ops.gen_query_conditions('uuid', '=', job_group_2.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond) assert len(job_group_inv) == 0 cond = res_ops.gen_query_conditions('uuid', '=', job2.uuid) job_inv = res_ops.query_resource(res_ops.SCHEDULERJOB, cond) assert len(job_inv) == 0
def test(): global project_uuid, project_admin_uuid, virtual_id_uuid, project_operator_uuid, plain_user_uuid flavor = case_flavor[os.environ.get('CASE_FLAVOR')] # 1 create project if flavor['target_role'] != 'system_admin': project_name = 'test_project' project = iam2_ops.create_iam2_project(project_name) project_uuid = project.uuid project_linked_account_uuid = project.linkedAccountUuid if flavor['target_role'] == 'project_admin': # 2 create virtual id project_admin_name = 'username' project_admin_password = '******' project_admin_uuid = iam2_ops.create_iam2_virtual_id(project_admin_name, project_admin_password).uuid virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernametwo', 'password').uuid # 3 create project admin 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) # login in project by project admin project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name, project_admin_password) project_login_uuid = iam2_ops.login_iam2_project(project_name, session_uuid=project_admin_session_uuid).uuid # iam2_ops.remove_attributes_from_iam2_virtual_id(virtual_id_uuid, attributes) elif flavor['target_role'] == 'project_operator': project_operator_name = 'username2' project_operator_password = '******' attributes = [{"name": "__ProjectOperator__", "value": project_uuid}] project_operator_uuid = iam2_ops.create_iam2_virtual_id(project_operator_name,project_operator_password,attributes=attributes).uuid virtual_id_uuid = iam2_ops.create_iam2_virtual_id('usernamethree','password').uuid # login in project by project operator iam2_ops.add_iam2_virtual_ids_to_project([project_operator_uuid],project_uuid) project_operator_session_uuid = iam2_ops.login_iam2_virtual_id(project_operator_name,project_operator_password) project_login_uuid = iam2_ops.login_iam2_project(project_name,session_uuid=project_operator_session_uuid).uuid elif flavor['target_role'] == 'project_member': plain_user_name = 'username' plain_user_password = '******' plain_user_uuid = iam2_ops.create_iam2_virtual_id(plain_user_name, plain_user_password, project_uuid=project_uuid).uuid # 3 add virtual id to project iam2_ops.add_iam2_virtual_ids_to_project([plain_user_uuid],project_uuid) # 4 login in project by plain user plain_user_session_uuid = iam2_ops.login_iam2_virtual_id(plain_user_name, plain_user_password) # 4 login in project #project_inv=iam2_ops.get_iam2_projects_of_virtual_id(plain_user_session_uuid) project_login_uuid = iam2_ops.login_iam2_project(project_name, plain_user_session_uuid).uuid elif flavor['target_role'] == 'system_admin': username = "******" password = '******' vid_tst_obj = test_vid.ZstackTestVid() test_stub.create_system_admin(username, password, vid_tst_obj) virtual_id_uuid = vid_tst_obj.get_vid().uuid project_login_uuid = acc_ops.login_by_account(username, password) # Image related ops: Add, Delete, Expunge, sync image size, Update QGA, delete, expunge if flavor['target_role'] == 'project_member': statements = [{"effect": "Allow", "actions": ["org.zstack.header.vm.**"]}, {"effect": "Allow", "actions": ["org.zstack.scheduler.**"]}] role_uuid = iam2_ops.create_role('test_role', statements).uuid iam2_ops.add_roles_to_iam2_virtual_id([role_uuid], plain_user_uuid) vm_creation_option = test_util.VmOption() l3_net_uuid = test_lib.lib_get_l3_by_name(os.environ.get('l3VlanNetwork3')).uuid if flavor['target_role'] != 'system_admin': acc_ops.share_resources([project_linked_account_uuid], [l3_net_uuid]) vm_creation_option.set_l3_uuids([l3_net_uuid]) image_uuid = test_lib.lib_get_image_by_name("centos").uuid vm_creation_option.set_image_uuid(image_uuid) if flavor['target_role'] != 'system_admin': acc_ops.share_resources([project_linked_account_uuid], [image_uuid]) instance_offering_uuid = test_lib.lib_get_instance_offering_by_name(os.environ.get('instanceOfferingName_s')).uuid vm_creation_option.set_instance_offering_uuid(instance_offering_uuid) if flavor['target_role'] != 'system_admin': acc_ops.share_resources([project_linked_account_uuid], [instance_offering_uuid]) vm_creation_option.set_name('vm_for_project_management') vm_creation_option.set_session_uuid(project_login_uuid) vm = test_stub.create_vm(image_uuid = image_uuid, session_uuid=project_login_uuid) # scheduler ops: start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None, session_uuid=project_login_uuid) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+5, None, 15, 'simple', session_uuid=project_login_uuid) schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.change_scheduler_state(schd_job1.uuid, 'disable', session_uuid=project_login_uuid) schd_ops.change_scheduler_state(schd_job1.uuid, 'enable', session_uuid=project_login_uuid) schd_ops.remove_scheduler_job_from_trigger(schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.del_scheduler_job(schd_job1.uuid, session_uuid=project_login_uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid, session_uuid=project_login_uuid) schd_ops.get_current_time() vm_ops.destroy_vm(vm.get_vm().uuid, session_uuid=project_login_uuid) vm_ops.expunge_vm(vm.get_vm().uuid, session_uuid=project_login_uuid) # 11 delete acc_ops.logout(project_login_uuid) if virtual_id_uuid != None: iam2_ops.delete_iam2_virtual_id(virtual_id_uuid) if project_admin_uuid != None: iam2_ops.delete_iam2_virtual_id(project_admin_uuid) if project_operator_uuid != None: iam2_ops.delete_iam2_virtual_id(project_operator_uuid) if plain_user_uuid != None: iam2_ops.delete_iam2_virtual_id(plain_user_uuid) if flavor['target_role'] != 'system_admin': iam2_ops.delete_iam2_project(project_uuid) iam2_ops.expunge_iam2_project(project_uuid) test_util.test_pass('success test iam2 login in by project admin!')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 10, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+10, 20) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 20, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+20, 20) test_stub.sleep_util(start_date + 45) test_util.test_dsc('check scheduler state after create scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', start_date + 10): test_util.test_fail( 'StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', start_date + 20): test_util.test_fail( 'StartVmInstanceJob not executed at expected timestamp range') schd_ops.change_scheduler_state(schd_job1.uuid, 'disable') schd_ops.change_scheduler_state(schd_job2.uuid, 'disable') current_time = int(time.time()) except_start_time = start_date + 20 * (( (current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after pause scheduler') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') if check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time + 10): test_util.test_fail( 'StopVmInstanceJob executed at unexpected timestamp range') if check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time + 20): test_util.test_fail( 'StartVmInstanceJob executed at unexpected timestamp range') schd_ops.change_scheduler_state(schd_job1.uuid, 'enable') schd_ops.change_scheduler_state(schd_job2.uuid, 'enable') current_time = int(time.time()) except_start_time = start_date + 20 * (( (current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after resume scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time + 10): test_util.test_fail( 'StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time + 20): test_util.test_fail( 'StartVmInstanceJob not executed at expected timestamp range') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.destroy() test_util.test_pass( 'Check Scheduler State after Pause and Resume Scheduler Success')
def test(): global vm global schd_job global schd_trigger global new_account vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) disk_offering = test_lib.lib_get_disk_offering_by_name(os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot scheduler testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) volume.detach() test_util.test_dsc('create snapshot scheduler') start_date = int(time.time()) #sp_option = test_util.SnapshotOption() #sp_option.set_name('simple_schduler_snapshot') #sp_option.set_volume_uuid(volume.get_volume().uuid) schd_job = schd_ops.create_scheduler_job('simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.get_volume().uuid, 'volumeSnapshot', None) schd_trigger = schd_ops.create_scheduler_trigger('simple_create_snapshot_scheduler', start_date+60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) #schd = vol_ops.create_snapshot_scheduler(sp_option, 'simple', 'simple_create_snapshot_scheduler', start_date+60, 120) check_scheduler_state(schd_job, 'Enabled') snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120*i - 2) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(start_date + 60 + 120*i + 65) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120*i + 65, snapshot_num+1)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) new_account = account_operations.create_account('new_account', 'password', 'Normal') res_ops.change_recource_owner(new_account.uuid, volume.get_volume().uuid) test_util.test_dsc('check scheduler state after changing the owner of volume') check_scheduler_state(schd_job, 'Enabled') current_time = int(time.time()) except_start_time = start_date + 120 * (((current_time - start_date) % 120) + 1) snapshot_num = (except_start_time - start_date) // 120 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(except_start_time + 60 + 120*i - 2) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (except_start_time + 60 + 120*i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(except_start_time + 60 + 120*i + 60) test_util.test_logger('check volume snapshot number at %s, there should be %s' % (except_start_time + 60 + 120*i + 65, snapshot_num+1)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() account_operations.delete_account(new_account.uuid) test_util.test_pass('Check Scheduler State after Changing Volume Owner Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 delete_policy = test_lib.lib_get_delete_policy('vm') vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm.set_delete_policy('Delay') start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+10, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+10, 20) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+20, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+20, 20) test_stub.sleep_util(start_date+45) test_util.test_dsc('check scheduler state after create scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', start_date+10): test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', start_date+20): test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range') vm.destroy() current_time = int(time.time()) except_start_time = start_date + 20 * (((current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after destroy vm') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') if check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+10): test_util.test_fail('StopVmInstanceJob executed at unexpected timestamp range') if check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+20): test_util.test_fail('StartVmInstanceJob executed at unexpected timestamp range') vm.recover() current_time = int(time.time()) except_start_time = start_date + 20 * (((current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after recover vm') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') # if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+10): # test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') # if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+20): # test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range' ) schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.set_delete_policy(delete_policy) vm.destroy() conditions = res_ops.gen_query_conditions('uuid', '=', schd_job1.uuid) if len(res_ops.query_resource(res_ops.SCHEDULERJOB, conditions)) > 0: test_util.test_fail('check stop vm scheduler, it is expected to be destroied, but it still exists') conditions = res_ops.gen_query_conditions('uuid', '=', schd_job2.uuid) if len(res_ops.query_resource(res_ops.SCHEDULERJOB, conditions)) > 0: test_util.test_fail('check start vm scheduler, it is expected to be destroied, but it still exists') test_util.test_pass('Check Scheduler State after Destroy and Recover VM Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 delete_policy = test_lib.lib_get_delete_policy('vm') vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm.set_delete_policy('Delay') start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 10, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+10, 20) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 20, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+20, 20) test_stub.sleep_util(start_date + 45) test_util.test_dsc('check scheduler state after create scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', start_date + 10): test_util.test_fail( 'StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', start_date + 20): test_util.test_fail( 'StartVmInstanceJob not executed at expected timestamp range') vm.destroy() current_time = int(time.time()) except_start_time = start_date + 20 * (( (current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after destroy vm') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') if check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time + 10): test_util.test_fail( 'StopVmInstanceJob executed at unexpected timestamp range') if check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time + 20): test_util.test_fail( 'StartVmInstanceJob executed at unexpected timestamp range') vm.recover() current_time = int(time.time()) except_start_time = start_date + 20 * (( (current_time - start_date) % 20) + 1) test_stub.sleep_util(except_start_time + 45) test_util.test_dsc('check scheduler state after recover vm') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') # if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+10): # test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') # if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+20): # test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range' ) schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.set_delete_policy(delete_policy) vm.destroy() conditions = res_ops.gen_query_conditions('uuid', '=', schd_job1.uuid) if len(res_ops.query_resource(res_ops.SCHEDULERJOB, conditions)) > 0: test_util.test_fail( 'check stop vm scheduler, it is expected to be destroied, but it still exists' ) conditions = res_ops.gen_query_conditions('uuid', '=', schd_job2.uuid) if len(res_ops.query_resource(res_ops.SCHEDULERJOB, conditions)) > 0: test_util.test_fail( 'check start vm scheduler, it is expected to be destroied, but it still exists' ) test_util.test_pass( 'Check Scheduler State after Destroy and Recover VM Success')
def test(): global vm global schd_job global schd_trigger global new_account vm = test_stub.create_vlan_vm() test_obj_dict.add_vm(vm) disk_offering = test_lib.lib_get_disk_offering_by_name( os.environ.get('smallDiskOfferingName')) volume_creation_option = test_util.VolumeOption() volume_creation_option.set_name('volume for snapshot scheduler testing') volume_creation_option.set_disk_offering_uuid(disk_offering.uuid) volume = test_stub.create_volume(volume_creation_option) test_obj_dict.add_volume(volume) volume.attach(vm) volume.detach() test_util.test_dsc('create snapshot scheduler') start_date = int(time.time()) #sp_option = test_util.SnapshotOption() #sp_option.set_name('simple_schduler_snapshot') #sp_option.set_volume_uuid(volume.get_volume().uuid) schd_job = schd_ops.create_scheduler_job( 'simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.get_volume().uuid, 'volumeSnapshot', None) schd_trigger = schd_ops.create_scheduler_trigger( 'simple_create_snapshot_scheduler', start_date + 60, None, 120, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger.uuid, schd_job.uuid) #schd = vol_ops.create_snapshot_scheduler(sp_option, 'simple', 'simple_create_snapshot_scheduler', start_date+60, 120) check_scheduler_state(schd_job, 'Enabled') snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 60 + 120 * i - 2) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120 * i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) snapshot_num += 1 test_stub.sleep_util(start_date + 60 + 120 * i + 65) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (start_date + 60 + 120 * i + 65, snapshot_num + 1)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) new_account = account_operations.create_account('new_account', 'password', 'Normal') res_ops.change_recource_owner(new_account.uuid, volume.get_volume().uuid) test_util.test_dsc( 'check scheduler state after changing the owner of volume') check_scheduler_state(schd_job, 'Disabled') current_time = int(time.time()) except_start_time = start_date + 120 * (( (current_time - start_date) % 120) + 1) for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(except_start_time + 60 + 120 * i - 2) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (except_start_time + 60 + 120 * i - 2, snapshot_num)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) test_stub.sleep_util(except_start_time + 60 + 120 * i + 60) test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (except_start_time + 60 + 120 * i + 65, snapshot_num + 1)) new_snapshot_num = query_snapshot_number(volume.get_volume().uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there sholuld be %s snapshots' % (snapshot_num)) schd_ops.del_scheduler_job(schd_job.uuid) schd_ops.del_scheduler_trigger(schd_trigger.uuid) vm.destroy() account_operations.delete_account(new_account.uuid) test_util.test_pass( 'Check Scheduler State after Changing Volume Owner Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 iam2_ops.clean_iam2_enviroment() zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid # 1 create project project_name = 'test_project' password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' project = iam2_ops.create_iam2_project(project_name) project_uuid = project.uuid linked_account_uuid = project.linkedAccountUuid attributes = [{"name": "__ProjectRelatedZone__", "value": zone_uuid}] iam2_ops.add_attributes_to_iam2_project(project_uuid, attributes) test_stub.share_admin_resource_include_vxlan_pool([linked_account_uuid]) # 2 create projectAdmin 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) project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name,password) project_admin_session_uuid = iam2_ops.login_iam2_project(project_name,project_admin_session_uuid).uuid # 3 create scheduler job and trigger vm = test_stub.create_vm(session_uuid=project_admin_session_uuid) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None,session_uuid=project_admin_session_uuid) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+60, None, 120, 'simple',session_uuid=project_admin_session_uuid) schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid,session_uuid=project_admin_session_uuid) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None,session_uuid=project_admin_session_uuid) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+120, None, 120, 'simple',session_uuid=project_admin_session_uuid) schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid,session_uuid=project_admin_session_uuid) acc_ops.logout(project_admin_session_uuid) # 4 delete project iam2_ops.delete_iam2_project(project_uuid) try: schd_job1_inv = res_ops.get_resource(res_ops.SCHEDULERJOB,uuid=schd_job1.uuid)[0] except: test_util.test_fail("delete project but not expunge,the schedulerjob [%s] is lost"%schd_job1.uuid) try: res_ops.get_resource(res_ops.SCHEDULERJOB,uuid=schd_job2.uuid)[0] except: test_util.test_fail("delete project but not expunge,the schedulerjob [%s] is lost"%schd_job2.uuid) try: schd_trigger1_inv = res_ops.get_resource(res_ops.SCHEDULERTRIGGER,uuid=schd_trigger1.uuid)[0] except: test_util.test_fail("delete project but not expunge,the scheduler trigger [%s] is lost"%schd_job1.uuid) try: res_ops.get_resource(res_ops.SCHEDULERTRIGGER,uuid=schd_trigger2.uuid)[0] except: test_util.test_fail("delete project but not expunge,the scheduler trigger [%s] is lost"%schd_job1.uuid) iam2_ops.recover_iam2_project(project_uuid) try: project_admin_session_uuid = iam2_ops.login_iam2_virtual_id(project_admin_name,password) project_admin_session_uuid = iam2_ops.login_iam2_project(project_name,project_admin_session_uuid).uuid except: test_util.test_fail("recover the deleted project , but can't login in") iam2_ops.delete_iam2_project(project_uuid) iam2_ops.expunge_iam2_project(project_uuid) # 5 check for cascade delete test_stub.check_resource_not_exist(schd_job1.uuid,res_ops.SCHEDULERJOB) test_stub.check_resource_not_exist(schd_job2.uuid,res_ops.SCHEDULERJOB) test_stub.check_resource_not_exist(schd_trigger1.uuid,res_ops.SCHEDULERTRIGGER) test_stub.check_resource_not_exist(schd_trigger2.uuid,res_ops.SCHEDULERTRIGGER) vm.clean() iam2_ops.clean_iam2_enviroment() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 iam2_ops.clean_iam2_enviroment() zone_uuid = res_ops.get_resource(res_ops.ZONE)[0].uuid # 1 create project project_name = 'test_project' password = \ 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86' project = iam2_ops.create_iam2_project(project_name) project_uuid = project.uuid linked_account_uuid = project.linkedAccountUuid attributes = [{"name": "__ProjectRelatedZone__", "value": zone_uuid}] iam2_ops.add_attributes_to_iam2_project(project_uuid, attributes) test_stub.share_admin_resource_include_vxlan_pool([linked_account_uuid]) # 2 create projectAdmin 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) project_admin_session_uuid = iam2_ops.login_iam2_virtual_id( project_admin_name, password) project_admin_session_uuid = iam2_ops.login_iam2_project( project_name, project_admin_session_uuid).uuid # 3 create scheduler job and trigger vm = test_stub.create_vm(session_uuid=project_admin_session_uuid) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job( 'simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None, session_uuid=project_admin_session_uuid) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 60, None, 120, 'simple', session_uuid=project_admin_session_uuid) schd_ops.add_scheduler_job_to_trigger( schd_trigger1.uuid, schd_job1.uuid, session_uuid=project_admin_session_uuid) schd_job2 = schd_ops.create_scheduler_job( 'simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None, session_uuid=project_admin_session_uuid) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 120, None, 120, 'simple', session_uuid=project_admin_session_uuid) schd_ops.add_scheduler_job_to_trigger( schd_trigger2.uuid, schd_job2.uuid, session_uuid=project_admin_session_uuid) acc_ops.logout(project_admin_session_uuid) # 4 delete project iam2_ops.delete_iam2_project(project_uuid) try: schd_job1_inv = res_ops.get_resource(res_ops.SCHEDULERJOB, uuid=schd_job1.uuid)[0] except: test_util.test_fail( "delete project but not expunge,the schedulerjob [%s] is lost" % schd_job1.uuid) try: res_ops.get_resource(res_ops.SCHEDULERJOB, uuid=schd_job2.uuid)[0] except: test_util.test_fail( "delete project but not expunge,the schedulerjob [%s] is lost" % schd_job2.uuid) try: schd_trigger1_inv = res_ops.get_resource(res_ops.SCHEDULERTRIGGER, uuid=schd_trigger1.uuid)[0] except: test_util.test_fail( "delete project but not expunge,the scheduler trigger [%s] is lost" % schd_job1.uuid) try: res_ops.get_resource(res_ops.SCHEDULERTRIGGER, uuid=schd_trigger2.uuid)[0] except: test_util.test_fail( "delete project but not expunge,the scheduler trigger [%s] is lost" % schd_job1.uuid) iam2_ops.recover_iam2_project(project_uuid) try: project_admin_session_uuid = iam2_ops.login_iam2_virtual_id( project_admin_name, password) project_admin_session_uuid = iam2_ops.login_iam2_project( project_name, project_admin_session_uuid).uuid except: test_util.test_fail("recover the deleted project , but can't login in") iam2_ops.delete_iam2_project(project_uuid) iam2_ops.expunge_iam2_project(project_uuid) # 5 check for cascade delete test_stub.check_resource_not_exist(schd_job1.uuid, res_ops.SCHEDULERJOB) test_stub.check_resource_not_exist(schd_job2.uuid, res_ops.SCHEDULERJOB) test_stub.check_resource_not_exist(schd_trigger1.uuid, res_ops.SCHEDULERTRIGGER) test_stub.check_resource_not_exist(schd_trigger2.uuid, res_ops.SCHEDULERTRIGGER) vm.clean() iam2_ops.clean_iam2_enviroment() test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def scheduler_vm_operations(vm, bss): vm_ops.stop_vm(vm.get_vm().uuid) volume = vm.get_vm().allVolumes[0] start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger( 'simple_start_vm_scheduler', start_date + 5, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) schd_job2 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger( 'simple_stop_vm_scheduler', start_date + 15, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) schd_job3 = schd_ops.create_scheduler_job('simple_reboot_vm_scheduler', 'simple_reboot_vm_scheduler', vm.get_vm().uuid, 'rebootVm', None) schd_trigger3 = schd_ops.create_scheduler_trigger( 'simple_reboot_vm_scheduler', start_date + 10, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger3.uuid, schd_job3.uuid) schd_job4 = schd_ops.create_scheduler_job( 'simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.uuid, 'volumeSnapshot', None) schd_trigger4 = schd_ops.create_scheduler_trigger( 'simple_create_snapshot_scheduler', start_date + 12, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger4.uuid, schd_job4.uuid) snapshot_num = 0 for i in range(0, 3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 5 + 15 * i + 1) #test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 5 +15*i, snapshot_num)) test_util.test_logger( 'check VM status at %s, VM is expected to start' % (start_date + 15 + 15 * i)) vm.update() if vm.get_vm().state != 'Starting' and vm.get_vm().state != 'Running': test_util.test_fail('VM is expected to start') test_stub.sleep_util(start_date + 10 + 15 * i + 1) test_util.test_logger( 'check VM status at %s, VM is expected to reboot' % (start_date + 10 + 15 * i)) vm.update() if not test_lib.lib_find_in_local_management_server_log( start_date + 10, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' % (start_date + 10 + 15 * i)) test_stub.sleep_util(start_date + 12 + 15 * i + 1) snapshot_num += 1 new_snapshot_num = query_snapshot_number(volume.uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there should be %s snapshots' % (snapshot_num)) #snapshot_num +=1 test_util.test_logger( 'check volume snapshot number at %s, there should be %s' % (start_date + 5 + 15 * i, snapshot_num)) #test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 6 + 15*i +1)) test_stub.sleep_util(start_date + 15 + 15 * i + 1) test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 15 + 15 * i)) vm.update() if vm.get_vm().state != 'Stopping' and vm.get_vm().state != 'Stopped': test_util.test_fail('VM is expected to stop') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) schd_ops.del_scheduler_job(schd_job3.uuid) schd_ops.del_scheduler_trigger(schd_trigger3.uuid) schd_ops.del_scheduler_job(schd_job4.uuid) schd_ops.del_scheduler_trigger(schd_trigger4.uuid) vm.update() vm_state = vm.get_vm().state snapshot_num_after = query_snapshot_number(volume.uuid) test_util.test_logger('snapshotnumber:%s' % snapshot_num_after) for i in range(3, 5): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 1 + 15 * i) vm.update() test_util.test_logger( 'check vm status at %s, vm is expected to stay in state %s' % (start_date + 5 + 15 * i, vm_state)) if vm.get_vm().state != vm_state: test_util.test_fail('vm is expected to stay in state %s' % (vm_state)) if snapshot_num_after != snapshot_num: test_util.test_fail( 'the number of snapshots is expected to stay in %s' % (snapshot_num)) vm.destroy() vm.expunge()
def test(): global vm global schd_job1 global schd_job2 global schd_trigger1 global schd_trigger2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+10, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) #schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date+10, 20) schd_job2 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+20, None, 20, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) #schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date+20, 20) test_stub.sleep_util(start_date+45) test_util.test_dsc('check scheduler state after create scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', start_date+10): test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', start_date+20): test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range') schd_ops.change_scheduler_state(schd_job1.uuid, 'disable') schd_ops.change_scheduler_state(schd_job2.uuid, 'disable') current_time = int(time.time()) except_start_time = start_date + 20 * (((current_time - start_date) // 20) + 1) test_stub.sleep_util(except_start_time+45) test_util.test_dsc('check scheduler state after pause scheduler') check_scheduler_state(schd_job1, 'Disabled') check_scheduler_state(schd_job2, 'Disabled') if check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+10): test_util.test_fail('StopVmInstanceJob executed at unexpected timestamp range') if check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+20): test_util.test_fail('StartVmInstanceJob executed at unexpected timestamp range') schd_ops.change_scheduler_state(schd_job1.uuid, 'enable') schd_ops.change_scheduler_state(schd_job2.uuid, 'enable') current_time = int(time.time()) except_start_time = start_date + 20 * (((current_time - start_date) // 20) + 1) test_stub.sleep_util(except_start_time+45) test_util.test_dsc('check scheduler state after resume scheduler') check_scheduler_state(schd_job1, 'Enabled') check_scheduler_state(schd_job2, 'Enabled') if not check_scheduler_msg('run scheduler for job: StopVmInstanceJob', except_start_time+10): test_util.test_fail('StopVmInstanceJob not executed at expected timestamp range') if not check_scheduler_msg('run scheduler for job: StartVmInstanceJob', except_start_time+20): test_util.test_fail('StartVmInstanceJob not executed at expected timestamp range') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) vm.destroy() test_util.test_pass('Check Scheduler State after Pause and Resume Scheduler Success')
def scheduler_vm_operations(vm,bss): vm_ops.stop_vm(vm.get_vm().uuid) volume = vm.get_vm().allVolumes[0] start_date = int(time.time()) schd_job1 = schd_ops.create_scheduler_job('simple_start_vm_scheduler', 'simple_start_vm_scheduler', vm.get_vm().uuid, 'startVm', None) schd_trigger1 = schd_ops.create_scheduler_trigger('simple_start_vm_scheduler', start_date+5, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger1.uuid, schd_job1.uuid) schd_job2 = schd_ops.create_scheduler_job('simple_stop_vm_scheduler', 'simple_stop_vm_scheduler', vm.get_vm().uuid, 'stopVm', None) schd_trigger2 = schd_ops.create_scheduler_trigger('simple_stop_vm_scheduler', start_date+15, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger2.uuid, schd_job2.uuid) schd_job3 = schd_ops.create_scheduler_job('simple_reboot_vm_scheduler', 'simple_reboot_vm_scheduler', vm.get_vm().uuid, 'rebootVm', None) schd_trigger3 = schd_ops.create_scheduler_trigger('simple_reboot_vm_scheduler', start_date+10, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger3.uuid, schd_job3.uuid) schd_job4 = schd_ops.create_scheduler_job('simple_create_snapshot_scheduler', 'simple_create_snapshot_scheduler', volume.uuid, 'volumeSnapshot', None) schd_trigger4 = schd_ops.create_scheduler_trigger('simple_create_snapshot_scheduler', start_date+12, None, 15, 'simple') schd_ops.add_scheduler_job_to_trigger(schd_trigger4.uuid, schd_job4.uuid) snapshot_num = 0 for i in range(0,3): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 5 + 15*i + 1) #test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 5 +15*i, snapshot_num)) test_util.test_logger('check VM status at %s, VM is expected to start' % (start_date + 15 + 15*i)) vm.update() if vm.get_vm().state != 'Starting' and vm.get_vm().state != 'Running': test_util.test_fail('VM is expected to start') test_stub.sleep_util(start_date +10 +15*i + 1) test_util.test_logger('check VM status at %s, VM is expected to reboot' % (start_date + 10 + 15*i)) vm.update() if not test_lib.lib_find_in_local_management_server_log(start_date+10, '[msg received]: {"org.zstack.header.vm.RebootVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('VM is expected to reboot start from %s' % (start_date+ 10 + 15*i)) test_stub.sleep_util(start_date + 12 + 15*i + 1) snapshot_num +=1 new_snapshot_num = query_snapshot_number(volume.uuid) if snapshot_num != new_snapshot_num: test_util.test_fail('there should be %s snapshots' % (snapshot_num)) #snapshot_num +=1 test_util.test_logger('check volume snapshot number at %s, there should be %s' % (start_date + 5 +15*i, snapshot_num)) #test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 6 + 15*i +1)) test_stub.sleep_util(start_date +15 +15*i + 1) test_util.test_logger('check VM status at %s, VM is expected to stop' % (start_date + 15 + 15*i)) vm.update() if vm.get_vm().state != 'Stopping' and vm.get_vm().state != 'Stopped': test_util.test_fail('VM is expected to stop') schd_ops.del_scheduler_job(schd_job1.uuid) schd_ops.del_scheduler_trigger(schd_trigger1.uuid) schd_ops.del_scheduler_job(schd_job2.uuid) schd_ops.del_scheduler_trigger(schd_trigger2.uuid) schd_ops.del_scheduler_job(schd_job3.uuid) schd_ops.del_scheduler_trigger(schd_trigger3.uuid) schd_ops.del_scheduler_job(schd_job4.uuid) schd_ops.del_scheduler_trigger(schd_trigger4.uuid) vm.update() vm_state = vm.get_vm().state snapshot_num_after = query_snapshot_number(volume.uuid) test_util.test_logger('snapshotnumber:%s' % snapshot_num_after) for i in range(3,5): test_util.test_logger('round %s' % (i)) test_stub.sleep_util(start_date + 1 +15*i) vm.update() test_util.test_logger('check vm status at %s, vm is expected to stay in state %s' % (start_date + 5 + 15*i, vm_state)) if vm.get_vm().state != vm_state: test_util.test_fail('vm is expected to stay in state %s' % (vm_state)) if snapshot_num_after != snapshot_num: test_util.test_fail('the number of snapshots is expected to stay in %s' % (snapshot_num)) vm.destroy() vm.expunge()
def test(): global job1 global job2 global job_group global trigger1 global trigger2 imagestore = test_lib.lib_get_image_store_backup_storage() if imagestore == None: test_util.test_skip('Required imagestore to test') vm1 = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm2 = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) volume = test_stub.create_volume() volume.attach(vm2) test_obj_dict.add_vm(vm1) test_obj_dict.add_vm(vm2) test_obj_dict.add_volume(volume) parameters = {'retentionType': 'Count', 'retentionValue': '10', 'backupStorageUuids': imagestore.uuid, 'remoteBackupStorageUuid': '', 'networkWriteBandwidth': '', 'networkReadBandwidth': '', 'volumeReadBandwidth': '', 'volumeWriteBandwidth': ''} test_util.test_logger(parameters) job1 = sch_ops.create_scheduler_job(name='root_volume', description='vm1 root volume backup', target_uuid=vm1.get_vm().allVolumes[0].uuid, type=volumeBackup, parameters=parameters) job2 = sch_ops.create_scheduler_job(name='data_volume', description='data volume backup', target_uuid=volume.get_volume().uuid, type=volumeBackup, parameters=parameters) name1 = 'job_group' job_group = sch_ops.create_scheduler_job_group(name=name1, description='vmbackup', type=volumeBackup, parameters=parameters) cond = res_ops.gen_query_conditions('uuid', '=', job_group.uuid) sch_ops.add_jobs_to_job_group([job1.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 1 sch_ops.add_jobs_to_job_group([job2.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 2 sch_ops.remove_jobs_from_job_group([job2.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 1 sch_ops.add_jobs_to_job_group([job2.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 2 sch_ops.remove_jobs_from_job_group([job1.uuid, job2.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 0 sch_ops.add_jobs_to_job_group([job1.uuid, job2.uuid], job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 2 sch_ops.del_scheduler_job(job2.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.jobsUuid) == 1 job2 = None trigger1 = sch_ops.create_scheduler_trigger('10sec', start_time=int(time.time() + 5), type='cron', cron='0/10 * * * * ?') trigger2 = sch_ops.create_scheduler_trigger('30sec', start_time=int(time.time() + 5), type='cron', cron='0/30 * * * * ?') sch_ops.add_scheduler_job_group_to_trigger(trigger1.uuid, job_group.uuid, triggerNow=True) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 1 sch_ops.add_scheduler_job_group_to_trigger(trigger2.uuid, job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 2 sch_ops.remove_scheduler_job_group_from_trigger(trigger2.uuid, job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 1 sch_ops.add_scheduler_job_group_to_trigger(trigger2.uuid, job_group.uuid, triggerNow=True) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 2 sch_ops.del_scheduler_trigger(trigger2.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond)[0] assert len(job_group_inv.triggersUuid) == 1 trigger2 = None sch_ops.del_scheduler_job_group(job_group.uuid) job_group_inv = res_ops.query_resource(res_ops.SCHEDULERJOBGROUP, cond) assert len(job_group_inv) == 0 job_group = None cond1 = res_ops.gen_query_conditions('uuid', '=', job1.uuid) cond2 = res_ops.gen_query_conditions('uuid', '=', trigger1.uuid) job_inv = res_ops.query_resource(res_ops.SCHEDULERJOB, cond1) assert len(job_inv) == 0 trigger_inv = res_ops.query_resource(res_ops.SCHEDULERTRIGGER, cond2) assert len(trigger_inv) == 1 trigger1 = None job1 = None test_lib.lib_robot_cleanup(test_obj_dict)