def test(): global vm global schd vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) vm.check() start_date = int(time.time()) 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) 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_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) 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.delete_scheduler(schd.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 {"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 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup stop and start VM scheduler') schd = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', 0, 1) actual_startDate = time.mktime(time.strptime(schd.startTime, '%b %d, %Y %H:%M:%S %p')) if actual_startDate != start_date and actual_startDate != start_date + 1: test_util.test_fail('startDate is expectd to set to now, which should be around %s' % (start_date)) test_stub.sleep_util(start_date+58) start_msg_mismatch = 0 for i in range(1, 58): if not test_lib.lib_find_in_local_management_server_log(start_date+i, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn('StopVmInstanceMsg is expected to execute at %s' % (start_date+i)) if start_msg_mismatch > 5: test_util.test_fail('%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) schd_ops.delete_scheduler(schd.uuid) try: vm.destroy() except: test_util.test_logger('expected exception when destroy VM since too many queued task') test_util.test_pass('Create Simple VM Start Scheduler Success')
def check_scheduler_msg(msg, timestamp): msg_mismatch = 0 for i in range(0, 20): if test_lib.lib_find_in_local_management_server_log(timestamp + i, msg, vm.get_vm().uuid): msg_mismatch = 1 return True if msg_mismatch == 0: return False
def test(): global vm global schds vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup start VM scheduler') for ops_id in range(1000): thread = threading.Thread(target=create_start_vm_scheduler, args=(vm.get_vm().uuid, start_date, ops_id, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) test_stub.sleep_util(start_date+200) start_msg_mismatch = 0 for i in range(0, 100): if not test_lib.lib_find_in_local_management_server_log(start_date+100+i, '[msg send]: org.zstack.header.vm.StartVmInstanceMsg {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn('StartVmInstanceMsg is expected to execute at %s' % (start_date+100+i)) if start_msg_mismatch > 5: test_util.test_fail('%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) for schd_job in schd_jobs: thread = threading.Thread(target=delete_scheduler_job, args=(schd_job.uuid, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) for schd_trigger in schd_triggers: thread = threading.Thread(target=delete_scheduler_trigger, args=(schd_trigger.uuid, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) try: vm.destroy() except: test_util.test_logger('expected exception when destroy VM since too many queued task') test_util.test_pass('Create 1000 Simple VM Start Scheduler Success')
def test(): global vm global schds vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup start VM scheduler') for ops_id in range(1000): thread = threading.Thread(target=create_start_vm_scheduler, args=(vm.get_vm().uuid, start_date, ops_id, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) test_stub.sleep_util(start_date+200) start_msg_mismatch = 0 for i in range(0, 99): if test_lib.lib_find_in_local_management_server_log(start_date+i, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn('StartVmInstanceMsg is not expected to execute at %s' % (start_date+i)) if start_msg_mismatch > 5: test_util.test_fail('%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) count0 = test_lib.lib_count_in_local_management_server_log(start_date+100, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the same second' % count0) count1 = test_lib.lib_count_in_local_management_server_log(start_date+100+1, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the next second' % count1) count2 = test_lib.lib_count_in_local_management_server_log(start_date+100+2, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the third second' % count2) if count0 + count1 + count2 < 900: test_util.test_fail('only %s of 1000 scheduler executed at the specified first 3 seconds' % (count0 + count1 + count2)) for schd in schds: thread = threading.Thread(target=delete_start_vm_scheduler, args=(schd.uuid, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) try: vm.destroy() except: test_util.test_logger('expected exception when destroy VM since too many queued task') test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def check_operation_result(self): time.sleep(30) start_msg_mismatch = 1 for k in range(0, 100): for i in range(0, self.i): vm_stat_flag=0 if not test_lib.lib_find_in_local_management_server_log(self.date+k, '[msg send]: {"org.zstack.header.vm.RebootVmInstanceMsg', self.vms[i].uuid): test_util.test_warn('RebootVmInstanceMsg is expected to execute at %s' % (self.date+k)) vm_stat_flag=1 start_msg_mismatch += 1 if vm_stat_flag == 0: break if start_msg_mismatch > 1000: test_util.test_fail('%s of 1000 RebootVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch))
def check_operation_result(self): time.sleep(30) start_msg_mismatch = 1 for k in range(0, 100): for i in range(0, self.i): vm_stat_flag=0 if not test_lib.lib_find_in_local_management_server_log(self.date+k, '[msg send]: {"org.zstack.header.vm.RebootVmInstanceMsg', self.vms[i].uuid): test_util.test_warn('RebootVmInstanceMsg is expected to execute at %s' % (self.date+k)) vm_stat_flag=1 start_msg_mismatch += 1 if vm_stat_flag == 0: break if start_msg_mismatch > 1000: test_util.test_fail('%s of 1000 RebootVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch))
def check_operation_result(self): time.sleep(30) start_msg_mismatch = 1 for k in range(0, 1000): for i in range(0, self.i): vm_stat_flag=0 vm=test_lib.lib_get_vm_by_uuid(self.vms[i].uuid) root_volume_uuid=test_lib.lib_get_root_volume_uuid(vm) if not test_lib.lib_find_in_local_management_server_log(self.date+k, '[msg send]: {"org.zstack.header.volume.CreateVolumeSnapshotMsg', self.vms[i].uuid): test_util.test_warn('CreateVolumeSnapshotMsg is expected to execute at %s' % (self.date+k)) vm_stat_flag=1 start_msg_mismatch += 1 if vm_stat_flag == 0: break if start_msg_mismatch > 1000: test_util.test_fail('%s of 1000 CreateVolumeSnapshotMsg not executed at expected timestamp' % (start_msg_mismatch))
def test(): global vm global schd vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup stop and start VM scheduler') schd = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', 0, 1) actual_startDate = time.mktime( time.strptime(schd.startTime, '%b %d, %Y %I:%M:%S %p')) if actual_startDate != start_date and actual_startDate != start_date + 1.0: test_util.test_fail( 'startDate is expectd to set to now, which should be around %s' % (start_date)) test_stub.sleep_util(start_date + 58) start_msg_mismatch = 0 for i in range(1, 58): if not test_lib.lib_find_in_local_management_server_log( start_date + i, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn( 'StopVmInstanceMsg is expected to execute at %s' % (start_date + i)) if start_msg_mismatch > 5: test_util.test_fail( '%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) schd_ops.delete_scheduler(schd.uuid) try: vm.destroy() except: test_util.test_logger( 'expected exception when destroy VM since too many queued task') test_util.test_pass('Create Simple VM 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 schd1 global schd2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup stop and start VM scheduler') schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_stop_vm_scheduler', start_date, 1) schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'simple', 'simple_start_vm_scheduler', start_date, 2) test_stub.sleep_util(start_date + 58) stop_msg_mismatch = 0 start_msg_mismatch = 0 for i in range(0, 58): if not test_lib.lib_find_in_local_management_server_log( start_date + i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn( 'StopVmInstanceMsg is expected to execute at %s' % (start_date + i)) if i % 2 == 0: if not test_lib.lib_find_in_local_management_server_log( start_date + i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn( 'StartVmInstanceMsg is expected to execute at %s' % (start_date + i)) else: if test_lib.lib_find_in_local_management_server_log( start_date + i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn( 'StartVmInstanceMsg is not expected to execute at %s' % (start_date + i)) if stop_msg_mismatch > 10: test_util.test_fail( '%s of 58 StopVmInstanceMsg not executed at expected timestamp' % (stop_msg_mismatch)) if start_msg_mismatch > 5: test_util.test_fail( '%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) test_util.test_logger('Update stop and start VM scheduler to cron type') start_date = int(time.time()) test_stub.sleep_util((start_date + 59) / 60 * 60) schd_ops.update_scheduler(schd1.uuid, 'cron', 'cron_stop_vm_scheduler2', None, None, None, '0 * * * * ?') schd_ops.update_scheduler(schd2.uuid, 'cron', 'cron_start_vm_scheduler2', None, None, None, '0 * * * * ?') change_date = int(time.time()) test_stub.sleep_util(start_date + 59) for i in range(2, 58): if test_lib.lib_find_in_local_management_server_log( change_date + i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail( 'StopVmInstanceMsg is not expected to execute at %s' % (change_date + i)) if test_lib.lib_find_in_local_management_server_log( change_date + i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail( 'StartVmInstanceMsg is not expected to execute at %s' % (change_date + i)) schd_ops.update_scheduler(schd1.uuid, 'cron', 'cron_stop_vm_scheduler3', None, None, None, '0/2 * * * * ?') schd_ops.update_scheduler(schd2.uuid, 'cron', 'cron_start_vm_scheduler3', None, None, None, '* * * * * ?') change_date = int(time.time()) test_stub.sleep_util(change_date + 60) stop_msg_mismatch = 0 start_msg_mismatch = 0 for i in range(1, 58): if (change_date + i) % 2 == 0: if not test_lib.lib_find_in_local_management_server_log( change_date + i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn( 'StopVmInstanceMsg is expected to execute at %s' % (change_date + i)) else: if test_lib.lib_find_in_local_management_server_log( change_date + i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn( 'StopVmInstanceMsg is not expected to execute at %s' % (change_date + i)) if not test_lib.lib_find_in_local_management_server_log( change_date + i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn( 'StartVmInstanceMsg is expected to execute at %s' % (change_date + i)) if stop_msg_mismatch > 5: test_util.test_fail( '%s of 58 StopVmInstanceMsg not executed at expected timestamp' % (stop_msg_mismatch)) if start_msg_mismatch > 10: test_util.test_fail( '%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) schd_ops.delete_scheduler(schd1.uuid) schd_ops.delete_scheduler(schd2.uuid) try: vm.destroy() except: test_util.test_logger( 'expected exception when destroy VM since too many queued task') 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 schds vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) start_date = int(time.time()) test_util.test_logger('Setup start VM scheduler') for ops_id in range(1000): thread = threading.Thread(target=create_start_vm_scheduler, args=( vm.get_vm().uuid, start_date, ops_id, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) test_stub.sleep_util(start_date + 400) start_msg_mismatch = 0 for i in range(0, 299): if test_lib.lib_find_in_local_management_server_log( start_date + i, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn( 'StartVmInstanceMsg is not expected to execute at %s' % (start_date + i)) if start_msg_mismatch > 5: test_util.test_fail( '%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) count0 = test_lib.lib_count_in_local_management_server_log( start_date + 300 - 1, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the same second' % count0) count1 = test_lib.lib_count_in_local_management_server_log( start_date + 300, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the next second' % count1) count2 = test_lib.lib_count_in_local_management_server_log( start_date + 300 + 1, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger('%s of 1000 scheduler executed at the third second' % count2) count3 = test_lib.lib_count_in_local_management_server_log( start_date + 300 + 2, '[msg send]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid) test_util.test_logger( '%s of 1000 scheduler executed at the fourth second' % count2) if count0 + count1 + count2 < 900: test_util.test_fail( 'only %s of 1000 scheduler executed at the specified first 4 seconds' % (count0 + count1 + count2 + count3)) for schd_job in schd_jobs: thread = threading.Thread(target=delete_scheduler_job, args=(schd_job.uuid, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) for schd_trigger in schd_triggers: thread = threading.Thread(target=delete_scheduler_trigger, args=(schd_trigger.uuid, )) while threading.active_count() > 10: time.sleep(0.5) exc = sys.exc_info() thread.start() while threading.activeCount() > 1: exc = sys.exc_info() time.sleep(0.1) try: vm.destroy() except: test_util.test_logger( 'expected exception when destroy VM since too many queued task') test_util.test_pass('Create Simple VM Stop Start Scheduler Success')
def test(): global vm global schd1 global schd2 vm = test_stub.create_vlan_vm(os.environ.get('l3VlanNetworkName1')) test_util.test_logger('Update stop and start VM scheduler to cron type') start_date = int(time.time()) test_stub.sleep_util((start_date+59)/60*60) schd1 = vm_ops.stop_vm_scheduler(vm.get_vm().uuid, 'cron', 'cron_stop_vm_scheduler', None, None, None, '0 * * * * ?') schd2 = vm_ops.start_vm_scheduler(vm.get_vm().uuid, 'cron', 'cron_start_vm_scheduler', None, None, None, '0 * * * * ?') change_date = int(time.time()) test_stub.sleep_util(start_date+30) for i in range(2, 30): if test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('StopVmInstanceMsg is not expected to execute at %s' % (change_date+i)) if test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): test_util.test_fail('StartVmInstanceMsg is not expected to execute at %s' % (change_date+i)) schd_ops.update_scheduler(schd1.uuid, 'simple', 'simple_stop_vm_scheduler2', start_date, 2, 10) schd_ops.update_scheduler(schd2.uuid, 'simple', 'simple_start_vm_scheduler2', start_date, 1, 20) change_date = int(time.time()) test_stub.sleep_util(change_date+60) stop_msg_mismatch = 0 start_msg_mismatch = 0 for i in range(1, 15): if (change_date+i-start_date) % 2 == 0: if not test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn('StopVmInstanceMsg is expected to execute at %s' % (change_date+i)) else: if test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn('StopVmInstanceMsg is not expected to execute at %s' % (change_date+i)) if not test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn('StartVmInstanceMsg is expected to execute at %s' % (change_date+i)) for i in range(21, 60): if test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StopVmInstanceMsg', vm.get_vm().uuid): stop_msg_mismatch += 1 test_util.test_warn('StopVmInstanceMsg is not expected to execute at %s' % (change_date+i)) if test_lib.lib_find_in_local_management_server_log(change_date+i, '[msg received]: {"org.zstack.header.vm.StartVmInstanceMsg', vm.get_vm().uuid): start_msg_mismatch += 1 test_util.test_warn('StartVmInstanceMsg is not expected to execute at %s' % (change_date+i)) if stop_msg_mismatch > 5: test_util.test_fail('%s of 58 StopVmInstanceMsg not executed at expected timestamp' % (stop_msg_mismatch)) if start_msg_mismatch > 10: test_util.test_fail('%s of 58 StartVmInstanceMsg not executed at expected timestamp' % (start_msg_mismatch)) schd_ops.delete_scheduler(schd1.uuid) schd_ops.delete_scheduler(schd2.uuid) try: vm.destroy() except: test_util.test_logger('expected exception when destroy VM since too many queued task') test_util.test_pass('Create Simple VM Stop Start Scheduler Success')