def test_idm__sync_lock_exclusive_twice(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == -11 # -EAGAIN a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0
def test_idm__sync_get_lock_shareable_mode(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 ret, mode = idm_scsi.idm_drive_lock_mode(lock_id0, DRIVE1) assert ret == 0 assert mode == idm_scsi.IDM_MODE_SHAREABLE a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0
def test_idm__sync_get_host_count(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id0, DRIVE1) assert ret == 0 assert count == 0 assert self == 1 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id0, DRIVE1) assert ret == 0 assert count == 0 assert self == 0
def test_idm__sync_read_lvb_1(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 5000) assert ret == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_read_lvb(lock_id0, host_id0, a, 8, DRIVE1) assert ret == 0 assert ord(a[0]) == 0 assert ord(a[1]) == 0 assert ord(a[2]) == 0 assert ord(a[3]) == 0 assert ord(a[4]) == 0 assert ord(a[5]) == 0 assert ord(a[6]) == 0 assert ord(a[7]) == 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0
def test_idm__sync_renew_timeout_4(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 5000) assert ret == 0 time.sleep(7) ret = idm_scsi.idm_drive_renew_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 5000) assert ret == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 # -ETIME or 0
def test_idm__sync_convert_2(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 ret = idm_scsi.idm_drive_convert_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0
def test_idm__sync_lock_shareable_two_hosts(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" host_id1 = "00000000000000000000000000000001" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, DRIVE1, 10000) assert ret == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, a, 8, DRIVE1) assert ret == 0
def test_idm__async_lock_shareable_two_locks(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" lock_id1 = "0000000000000000000000000000000000000000000000000000000000000001" host_id0 = "00000000000000000000000000000000" ret, handle1 = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_lock_async(lock_id1, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == 0 ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle1 = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_unlock_async(lock_id1, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == 0 ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == 0
def test_idm__async_lock_exclusive_two_drives(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret, handle1 = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE2, 10000) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == 0 ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle1 = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE2) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == 0 ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == 0
def test_idm__sync_two_hosts_get_host_count(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" host_id1 = "00000000000000000000000000000001" host_id2 = "00000000000000000000000000000002" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, DRIVE1, 10000) assert ret == 0 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id0, DRIVE1) assert ret == 0 assert count == 1 assert self == 1 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id1, DRIVE1) assert ret == 0 assert count == 1 assert self == 1 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id2, DRIVE1) assert ret == 0 assert count == 2 assert self == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, a, 8, DRIVE1) assert ret == 0 ret, count, self = idm_scsi.idm_drive_lock_count(lock_id0, host_id0, DRIVE1) assert ret == 0 assert count == 0 assert self == 0
def test_idm__async_renew_timeout_2(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 time.sleep(7) ret, handle = idm_scsi.idm_drive_renew_lock_async( lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 # -ETIME or 0
def test_idm__async_read_lvb_1(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) ret, handle = idm_scsi.idm_drive_read_lvb_async(lock_id0, host_id0, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_read_lvb_async_result(handle, a, 8) assert ret == 0 assert result == 0 assert ord(a[0]) == 0 assert ord(a[1]) == 0 assert ord(a[2]) == 0 assert ord(a[3]) == 0 assert ord(a[4]) == 0 assert ord(a[5]) == 0 assert ord(a[6]) == 0 assert ord(a[7]) == 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0
def test_idm__async_convert_2(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_convert_lock_async( lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0
def test_idm__sync_break_lock_3(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" host_id1 = "00000000000000000000000000000001" ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 5000) assert ret == 0 ret = idm_scsi.idm_drive_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id1, DRIVE1, 5000) assert ret == -16 # -EBUSY time.sleep(7) ret = idm_scsi.idm_drive_break_lock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id1, DRIVE1, 10000) assert ret == 0 # Break successfully a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == -2 # -ENOENT ret = idm_scsi.idm_drive_unlock(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id1, a, 8, DRIVE1) assert ret == 0
def test_idm__async_break_lock_3(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" host_id1 = "00000000000000000000000000000001" ret, handle1 = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 5000) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_EXCLUSIVE, host_id1, DRIVE1, 5000) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == 0 ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == -16 # -EBUSY time.sleep(7) ret, handle = idm_scsi.idm_drive_break_lock_async( lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, DRIVE1, 5000) assert ret == 0 # Break successfully wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle1 = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 ret, handle2 = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle1) wait_for_scsi_response(handle2) ret, result = idm_scsi.idm_drive_async_result(handle1) assert ret == 0 assert result == -2 # -ENOENT ret, result = idm_scsi.idm_drive_async_result(handle2) assert ret == 0 assert result == 0
def test_idm__async_three_hosts_get_host_count(idm_cleanup): lock_id0 = "0000000000000000000000000000000000000000000000000000000000000000" host_id0 = "00000000000000000000000000000000" host_id1 = "00000000000000000000000000000001" host_id2 = "00000000000000000000000000000002" ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_lock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id2, DRIVE1, 10000) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_lock_count_async(lock_id0, host_id0, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, count, self, result = idm_scsi.idm_drive_lock_count_async_result( handle) assert ret == 0 assert result == 0 assert count == 2 assert self == 1 ret, handle = idm_scsi.idm_drive_lock_count_async(lock_id0, host_id1, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, count, self, result = idm_scsi.idm_drive_lock_count_async_result( handle) assert ret == 0 assert result == 0 assert count == 2 assert self == 1 ret, handle = idm_scsi.idm_drive_lock_count_async(lock_id0, host_id2, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, count, self, result = idm_scsi.idm_drive_lock_count_async_result( handle) assert ret == 0 assert result == 0 assert count == 2 assert self == 1 a = idm_scsi.charArray(8) a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id0, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id1, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_unlock_async(lock_id0, idm_scsi.IDM_MODE_SHAREABLE, host_id2, a, 8, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, result = idm_scsi.idm_drive_async_result(handle) assert ret == 0 assert result == 0 ret, handle = idm_scsi.idm_drive_lock_count_async(lock_id0, host_id0, DRIVE1) assert ret == 0 wait_for_scsi_response(handle) ret, count, self, result = idm_scsi.idm_drive_lock_count_async_result( handle) assert ret == 0 assert result == 0 assert count == 0 assert self == 0