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
