def testGetVDICopies(self):
self.assertTrue(fixture.CreateVDI("alpha"))
self.assertTrue(fixture.CreateVDI("bravo"))
vdis = fixture.ListVDI()
self.assertEqual(2, len(vdis))
alpha = self._assertUniqueName("alpha", vdis)
a_vid = alpha["vdi_id"]
bravo = self._assertUniqueName("bravo", vdis)
b_vid = bravo["vdi_id"]
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
status = client.get_vdi_copies(1)
self.assertEqual(2, len(status))
a_state = self._assertUnique(lambda x: x.vid == a_vid, status)
self.assertEqual(2, a_state.nr_copies)
self.assertEqual(0, a_state.snapshot)
self.assertEqual(0, a_state.deleted)
self.assertEqual(0, a_state.copy_policy)
self.assertEqual(22, a_state.block_size_shift)
self.assertEqual(0, a_state.parent_vid)
b_state = self._assertUnique(lambda x: x.vid == b_vid, status)
self.assertEqual(2, b_state.nr_copies)
self.assertEqual(0, b_state.snapshot)
self.assertEqual(0, b_state.deleted)
self.assertEqual(0, b_state.copy_policy)
self.assertEqual(22, b_state.block_size_shift)
self.assertEqual(0, b_state.parent_vid)
def testCloneVDI(self):
self.assertTrue(fixture.CreateVDI("alpha", 4 * (1024**2)))
alpha = filter(lambda x: x["name"] == "alpha", fixture.ListVDI())
self.assertEquals(1, len(alpha))
alpha = alpha[0]
self.assertEquals(4 * (1024**2), alpha["nb_size"])
contentToWrite = os.urandom(4 * (1024**2))
self.assertEquals(4 * (1024**2), len(contentToWrite))
self.assertTrue(fixture.WriteVDI("alpha", contentToWrite))
self.assertTrue(fixture.SnapshotVDI("alpha", "alpha_1"))
self.assertTrue(fixture.CloneVDI("alpha", "alpha_1", "bravo"))
pred = lambda x: x["cloned"] and x["name"] == "bravo"
self.assertEquals(1, len(filter(pred, fixture.ListVDI())))
self.assertTrue(fixture.WriteVDI("alpha", os.urandom(4 * (1024**2))))
contentRead = fixture.ReadVDI("bravo")
self.assertEquals(4 * (1024**2), len(contentRead))
expected = hashlib.md5(contentToWrite).digest()
actual = hashlib.md5(contentRead).digest()
self.assertEquals(expected, actual)
self.assertTrue(fixture.DeleteVDI("alpha", "alpha_1"))
self.assertTrue(fixture.DeleteVDI("alpha"))
self.assertTrue(fixture.WriteVDI("bravo", os.urandom(4 * (1024**2))))
self.assertTrue(fixture.DeleteVDI("bravo"))
def testCreateAndDeleteVDI(self):
self.assertEquals(0, len(fixture.ListVDI()))
self.assertTrue(fixture.CreateVDI("alpha", 128 * (1024**2)))
self.assertTrue(fixture.CreateVDI("bravo", 192 * (1024**2)))
vdis = fixture.ListVDI()
self.assertEquals(2, len(vdis))
alpha = filter(lambda x: x["name"] == "alpha", vdis)
self.assertEquals(1, len(alpha))
self.assertEquals(128 * (1024**2), alpha[0]["nb_size"])
bravo = filter(lambda x: x["name"] == "bravo", vdis)
self.assertEquals(1, len(bravo))
self.assertEquals(192 * (1024**2), bravo[0]["nb_size"])
self.assertTrue(fixture.DeleteVDI("alpha"))
self.assertEquals(1, len(fixture.ListVDI()))
self.assertTrue(fixture.DeleteVDI("bravo"))
self.assertEquals(0, len(fixture.ListVDI()))
def testReadObjOffset(self):
NB_OBJECT = 1 << 22
NB_SUBOBJECT = NB_OBJECT / 4
assert NB_OBJECT % NB_SUBOBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_OBJECT))
alpha = self._assertUniqueName("alpha", fixture.ListVDI())
self.assertEqual(NB_OBJECT, alpha["nb_size"])
a_vid = alpha["vdi_id"]
oid = a_vid << 32
contentToWrite = os.urandom(NB_OBJECT)
self.assertEqual(NB_OBJECT, len(contentToWrite))
self.assertTrue(fixture.WriteVDI("alpha", contentToWrite))
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
for i in range(NB_OBJECT / NB_SUBOBJECT):
s = NB_SUBOBJECT * i
e = NB_SUBOBJECT * (i + 1)
response = client.read_obj(oid, s, NB_SUBOBJECT)
contentRead = response.data
self.assertEqual(NB_SUBOBJECT, len(contentRead))
expected = hashlib.md5(contentToWrite[s:e]).digest()
actual = hashlib.md5(contentRead).digest()
self.assertEqual(expected, actual)
def testRemovePeer(self):
NB_OBJECT = 1 << 22
NB_VDI = NB_OBJECT * 4
assert NB_VDI % NB_OBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_VDI))
a_vid = self._assertGetVid("alpha", NB_VDI)
contentToWrite = self._assertMakeRandom("alpha", NB_VDI)
obj_set_before = set()
for (img, mnt) in self._disks:
obj_set_before |= set(fixture.GetObjFileName(mnt))
expected_remove_file = list(sorted(obj_set_before))[0]
remove_oid = long(expected_remove_file, 16)
obj_set_after = set()
for p in self.__class__._ports:
for result in fixture.GetObjFileName(self._disks[p - 7000][1]):
if result == expected_remove_file:
client = sheep.SheepdogClient(port=p)
self.assertTrue(client.remove_peer(remove_oid, 1, 0))
obj_set_after |= set(
fixture.GetObjFileName(self._disks[p - 7000][1]))
actual_remove_list = list(obj_set_before - obj_set_after)
self.assertEqual(1, len(actual_remove_list))
actual_remove_file = actual_remove_list[0]
self.assertEqual(expected_remove_file, actual_remove_file)
def testReadPeer(self):
NB_OBJECT = 1 << 22
NB_VDI = NB_OBJECT * 4
assert NB_VDI % NB_OBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_VDI))
a_vid = self._assertGetVid("alpha", NB_VDI)
contentToWrite = self._assertMakeRandom("alpha", NB_VDI)
p = 7000
client = sheep.SheepdogClient(port=p)
for i in range(NB_VDI / NB_OBJECT):
oid = (a_vid << 32) | i
obj_name = format(oid, 'x').zfill(16)
obj_full_path = self.__class__._disks[p -
7000][1] + "/obj/" + obj_name
check_path_list = fixture.FindObjFileName(self.__class__._disks,
obj_name)
self.assertEqual(self.__class__._COPIES, len(check_path_list))
for check_path in check_path_list:
if check_path == obj_full_path:
response = client.read_peer(oid, NB_OBJECT, 1, 0)
actual = hashlib.md5(response.data).hexdigest()
expected = fixture.GetMd5(obj_full_path)
def testWriteObj(self):
NB_OBJECT = 1 << 22
NB_VDI = NB_OBJECT * 4
assert NB_VDI % NB_OBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_VDI))
a_vid = self._assertGetVid("alpha", NB_VDI)
self._assertMakeZero("alpha", NB_VDI)
p = 7000
oids = []
contentToWrite = {}
client = sheep.SheepdogClient(port=p)
for i in range(NB_VDI / NB_OBJECT):
oid = (a_vid << 32) | i
oids.append(oid)
contentToWrite[oid] = os.urandom(NB_OBJECT)
response = client.write_obj(oid, contentToWrite[oid], 0)
for oid in oids:
obj_name = format(oid, 'x').zfill(16)
find_lists = fixture.FindObjFileName(self._disks, obj_name)
self.assertEqual(self._COPIES, len(find_lists))
expected = hashlib.md5(contentToWrite[oid]).hexdigest()
for rslt in find_lists:
actual = fixture.GetMd5(rslt)
self.assertEqual(expected, actual)
def testGetVDICopiesDeleted(self):
self.assertTrue(fixture.CreateVDI("alpha"))
self.assertTrue(fixture.DeleteVDI("alpha"))
self.assertEqual(0, len(fixture.ListVDI()))
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
status = client.get_vdi_copies(1)
a_state = self._assertUnique(None, status)
self.assertEqual(1, a_state.deleted)
def testGetVDIsFrom(self):
self.assertTrue(fixture.CreateVDI("alpha"))
self.assertTrue(fixture.CreateVDI("bravo"))
vdis = fixture.ListVDI()
self.assertEqual(2, len(vdis))
alpha = self._assertUniqueName("alpha", vdis)
a_vid = alpha["vdi_id"]
bravo = self._assertUniqueName("bravo", vdis)
b_vid = bravo["vdi_id"]
self.assertTrue(fixture.DeleteVDI("bravo"))
self.assertEqual(1, len(fixture.ListVDI()))
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
# before
status = client.get_vdi_copies(1)
self.assertEqual(2, len(status))
a_state = self._assertUnique(lambda x: x.vid == a_vid, status)
b_state = self._assertUnique(lambda x: x.vid == b_vid, status)
self.assertEqual(1, b_state.deleted)
# after
deleted = client.get_del_vids()
self.assertEqual(1, len(deleted))
self.assertTrue(a_vid not in deleted)
self.assertTrue(b_vid in deleted)
inuse = client.get_vids()
self.assertTrue(a_vid in inuse)
a_inode = client.get_inode(a_vid)
self.assertEqual(a_state.nr_copies, a_inode.nr_copies)
self.assertEqual(bool(a_state.snapshot), bool(a_inode.snap_ctime))
self.assertEqual(a_state.copy_policy, a_inode.copy_policy)
self.assertEqual(a_state.block_size_shift,
a_inode.block_size_shift)
self.assertEqual(a_state.parent_vid, a_inode.parent_vdi_id)
def testReadDelVDIs(self):
self.assertTrue(fixture.CreateVDI("alpha"))
alpha = self._assertUniqueName("alpha", fixture.ListVDI())
a_vid = alpha["vdi_id"]
self.assertTrue(fixture.DeleteVDI("alpha"))
self.assertEqual(0, len(fixture.ListVDI()))
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
deleted = client.get_del_vids()
self.assertEqual(1, len(deleted))
self.assertTrue(a_vid in deleted)
def testGetObjList(self):
NB_OBJECT = 1 << 22
NB_VDI = NB_OBJECT * 4
assert NB_VDI % NB_OBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_VDI))
a_vid = self._assertGetVid("alpha", NB_VDI)
contentToWrite = self._assertMakeRandom("alpha", NB_VDI)
for p in self.__class__._ports:
ls_objects = set(fixture.GetObjFileName(self._disks[p - 7000][1]))
client = sheep.SheepdogClient(port=p)
rsp_objects = set(client.get_obj_list(NB_VDI, 1))
self.assertEqual(ls_objects, rsp_objects)
def testWriteAndReadVDI(self):
self.assertTrue(fixture.CreateVDI("alpha", 4 * (1024**2)))
alpha = filter(lambda x: x["name"] == "alpha", fixture.ListVDI())
self.assertEquals(1, len(alpha))
alpha = alpha[0]
self.assertEquals(4 * (1024**2), alpha["nb_size"])
contentToWrite = os.urandom(4 * (1024**2))
self.assertEquals(4 * (1024**2), len(contentToWrite))
self.assertTrue(fixture.WriteVDI("alpha", contentToWrite))
contentRead = fixture.ReadVDI("alpha")
self.assertEquals(4 * (1024**2), len(contentRead))
expected = hashlib.md5(contentToWrite).digest()
actual = hashlib.md5(contentRead).digest()
self.assertEquals(expected, actual)
def testReadVDIs(self):
self.assertTrue(fixture.CreateVDI("alpha"))
self.assertTrue(fixture.SnapshotVDI("alpha", "alpha_1"))
vdis = fixture.ListVDI()
self.assertEqual(2, len(vdis))
alpha = self._assertUnique(lambda x: not x["snapshot"], vdis)
self.assertEqual("alpha", alpha["name"])
a_vid = alpha["vdi_id"]
snap = self._assertUnique(lambda x: x["snapshot"], vdis)
self.assertEqual("alpha", snap["name"])
self.assertEqual("alpha_1", snap["tag"])
s_vid = snap["vdi_id"]
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
inuse = client.get_vids()
self.assertEqual(2, len(inuse))
self.assertTrue(a_vid in inuse)
self.assertTrue(s_vid in inuse)
def testReadObjOffset(self):
NB_OBJECT = 1 << 22
NB_SUBOBJECT = NB_OBJECT / 4
assert NB_OBJECT % NB_SUBOBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_OBJECT))
a_vid = self._assertGetVid("alpha", NB_OBJECT)
oid = a_vid << 32
contentToWrite = self._assertMakeRandom("alpha", NB_OBJECT)
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
for i in range(NB_OBJECT / NB_SUBOBJECT):
s = NB_SUBOBJECT * i
e = NB_SUBOBJECT * (i + 1)
response = client.read_obj(oid, s, NB_SUBOBJECT)
contentRead = response.data
self.assertEqual(NB_SUBOBJECT, len(contentRead))
expected = hashlib.md5(contentToWrite[s:e]).digest()
actual = hashlib.md5(contentRead).digest()
self.assertEqual(expected, actual)
def testCreateAndWritePeer(self):
NB_OBJECT = 1 << 22
NB_VDI = NB_OBJECT * 4
assert NB_VDI % NB_OBJECT == 0
self.assertTrue(fixture.CreateVDI("alpha", NB_VDI))
a_vid = self._assertGetVid("alpha", NB_VDI)
p = 7000
client = sheep.SheepdogClient(port=p)
for i in range(NB_VDI / NB_OBJECT):
oid = (a_vid << 32) | i
contentToWrite = os.urandom(NB_OBJECT)
response = client.create_and_write_peer(oid, contentToWrite, 1, 0)
obj_name = format(oid, 'x').zfill(16)
find_result = fixture.FindObjFileName(self._disks, obj_name)
self.assertEqual(1, len(find_result))
expected = hashlib.md5(contentToWrite).hexdigest()
actual = fixture.GetMd5(find_result[0])
self.assertEqual(expected, actual)
def testGetVDICopiesSnapshot(self):
self.assertTrue(fixture.CreateVDI("alpha"))
self.assertTrue(fixture.SnapshotVDI("alpha", "alpha_1"))
vdis = fixture.ListVDI()
self.assertEqual(2, len(vdis))
alpha = self._assertUnique(lambda x: not x["snapshot"], vdis)
self.assertEqual("alpha", alpha["name"])
a_vid = alpha["vdi_id"]
snap = self._assertUnique(lambda x: x["snapshot"], vdis)
self.assertEqual("alpha", snap["name"])
self.assertEqual("alpha_1", snap["tag"])
s_vid = snap["vdi_id"]
for p in self.__class__._ports:
client = sheep.SheepdogClient(port=p)
status = client.get_vdi_copies(1)
self.assertEqual(2, len(status))
a_state = self._assertUnique(lambda x: x.vid == a_vid, status)
self.assertEqual(2, a_state.nr_copies)
self.assertEqual(0, a_state.snapshot)
self.assertEqual(0, a_state.deleted)
self.assertEqual(0, a_state.copy_policy)
self.assertEqual(22, a_state.block_size_shift)
self.assertEqual(s_vid, a_state.parent_vid)
s_state = self._assertUnique(lambda x: x.vid == s_vid, status)
self.assertEqual(2, s_state.nr_copies)
self.assertEqual(1, s_state.snapshot)
self.assertEqual(0, s_state.deleted)
self.assertEqual(0, s_state.copy_policy)
self.assertEqual(22, s_state.block_size_shift)
self.assertEqual(0, s_state.parent_vid)
