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')
