def tearDown(self):
try:
root_volume = list_volumes(self.apiclient,
virtualmachineid=self.vm_1.id,
type='ROOT',
listall=True)
self.vm_1.stop(self.apiclient)
snaps = []
for i in range(2):
root_vol_snap = Snapshot.create(self.apiclient,
root_volume[0].id)
self.assertEqual(
root_vol_snap.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
snaps.append(root_vol_snap)
for snap in snaps:
self.assertNotEqual(
self.dbclient.execute(
"select status from snapshots where name='%s'" %
snap.name), "Destroyed")
for snap in snaps:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient,
self.config, self.zone.id, snap.id))
self.account.delete(self.apiclient)
for snap in snaps:
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where name='%s'" %
snap.name)[0][0], "Destroyed")
for snap in snaps:
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient,
self.config, self.zone.id, snap.id))
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test_02_snapshot_data_disk(self):
"""Test Snapshot Data Disk
"""
volume = list_volumes(
self.apiclient,
virtualmachineid=self.virtual_machine_with_disk.id,
type='DATADISK',
listall=True)
self.assertEqual(isinstance(volume, list), True,
"Check list response returns a valid list")
self.debug("Creating a Snapshot from data volume: %s" % volume[0].id)
snapshot = Snapshot.create(self.apiclient,
volume[0].id,
account=self.account.name,
domainid=self.account.domainid)
snapshots = list_snapshots(self.apiclient, id=snapshot.id)
self.assertEqual(isinstance(snapshots, list), True,
"Check list response returns a valid list")
self.assertNotEqual(snapshots, None,
"Check if result exists in list item call")
self.assertEqual(snapshots[0].id, snapshot.id,
"Check resource id in list resources call")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
return
def test_04_snapshot_limit(self):
"""Test snapshot limit in snapshot policies
"""
# Validate the following
# 1. Perform hourly recurring snapshot on the root disk of VM and keep
# the maxsnapshots as 1
# 2. listSnapshots should list the snapshot that was created
# snapshot folder in secondary storage should contain only one
# snapshot image(/secondary/snapshots/$accountid/$volumeid/)
# Get the Root disk of VM
volumes = list_volumes(self.apiclient, virtualmachineid=self.virtual_machine.id, type="ROOT", listall=True)
self.assertEqual(isinstance(volumes, list), True, "Check list response returns a valid list")
volume = volumes[0]
# Create a snapshot policy
recurring_snapshot = SnapshotPolicy.create(self.apiclient, volume.id, self.services["recurring_snapshot"])
self.cleanup.append(recurring_snapshot)
snapshot_policy = list_snapshot_policy(self.apiclient, id=recurring_snapshot.id, volumeid=volume.id)
self.assertEqual(isinstance(snapshot_policy, list), True, "Check list response returns a valid list")
self.assertNotEqual(snapshot_policy, None, "Check if result exists in list item call")
self.assertEqual(
snapshot_policy[0].id, recurring_snapshot.id, "Check recurring snapshot id in list resources call"
)
self.assertEqual(
snapshot_policy[0].maxsnaps,
self.services["recurring_snapshot"]["maxsnaps"],
"Check interval type in list resources call",
)
# Sleep for (maxsnaps+1) hours to verify
# only maxsnaps snapshots are retained
time.sleep((int(self.services["recurring_snapshot"]["maxsnaps"]) + 1) * 3600)
# Verify the snapshot was created or not
snapshots = list_snapshots(
self.apiclient,
volumeid=volume.id,
intervaltype=self.services["recurring_snapshot"]["intervaltype"],
snapshottype="RECURRING",
listall=True,
)
self.assertEqual(isinstance(snapshots, list), True, "Check list response returns a valid list")
self.assertEqual(
len(snapshots),
self.services["recurring_snapshot"]["maxsnaps"],
"Check maximum number of recurring snapshots retained",
)
snapshot = snapshots[0]
# Sleep to ensure that snapshot is reflected in sec storage
time.sleep(self.services["sleep"])
self.assertTrue(is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config, self.zone.id, snapshot.id))
return
def test_02_snapshot_data_disk(self):
"""Test Snapshot Data Disk
"""
volume = list_volumes(
self.apiclient,
virtualmachineid=self.virtual_machine_with_disk.id,
type='DATADISK',
listall=True
)
self.assertEqual(
isinstance(volume, list),
True,
"Check list response returns a valid list"
)
self.debug("Creating a Snapshot from data volume: %s" % volume[0].id)
snapshot = Snapshot.create(
self.apiclient,
volume[0].id,
account=self.account.name,
domainid=self.account.domainid
)
snapshots = list_snapshots(
self.apiclient,
id=snapshot.id
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"Check if result exists in list item call"
)
self.assertEqual(
snapshots[0].id,
snapshot.id,
"Check resource id in list resources call"
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
return
def test_04_delete_snapshot(self):
"""Test Delete Snapshot
"""
# 1. Snapshot the Volume
# 2. Delete the snapshot
# 3. Verify snapshot is removed by calling List Snapshots API
# 4. Verify snapshot was removed from image store
self.debug("Creating volume under account: %s" % self.account.name)
volume = Volume.create(self.apiclient,
self.services["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id)
self.debug("Created volume: %s" % volume.id)
self.debug("Attaching volume to vm: %s" % self.virtual_machine.id)
self.virtual_machine.attach_volume(self.apiclient, volume)
self.debug("Volume attached to vm")
volumes = list_volumes(self.apiclient,
virtualmachineid=self.virtual_machine.id,
type='DATADISK',
id=volume.id)
self.assertEqual(isinstance(volumes, list), True,
"Check list response returns a valid list")
snapshot = Snapshot.create(self.apiclient,
volumes[0].id,
account=self.account.name,
domainid=self.account.domainid)
snapshot.delete(self.apiclient)
snapshots = list_snapshots(self.apiclient, id=snapshot.id)
self.assertEqual(snapshots, None,
"Check if result exists in list item call")
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
return
def tearDown(self):
try:
root_volume = list_volumes(
self.apiclient,
virtualmachineid=self.vm_1.id,
type='ROOT',
listall=True
)
self.vm_1.stop(self.apiclient)
snaps = []
for i in range(2):
root_vol_snap = Snapshot.create(
self.apiclient,
root_volume[0].id)
self.assertEqual(
root_vol_snap.state,
"BackedUp",
"Check if the data vol snapshot state is correct "
)
snaps.append(root_vol_snap)
for snap in snaps:
self.assertNotEqual(
self.dbclient.execute(
"select status from snapshots where name='%s'" %
snap.name),
"Destroyed"
)
for snap in snaps:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snap.id))
self.account.delete(self.apiclient)
for snap in snaps:
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where name='%s'" %
snap.name)[0][0],
"Destroyed"
)
for snap in snaps:
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snap.id))
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def test_02_volume_max_snapshot(self):
""" Test Volume Snapshot
# 1. Create Hourly reccuring snapshot policy with maxsnaps=2
verify that when 3rd snapshot is taken first snapshot gets deleted
"""
if self.hypervisor.lower() not in ["kvm", "vmware"]:
self.skipTest("Skip test for hypervisor other than KVM and VMWare")
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_1 = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_1.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
snap_to_delete = snapshots[0]
time.sleep((self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600)
snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(snap_to_delete not in snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0], "Destroyed")
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snap_to_delete.id))
# DATA DISK
recurring_snapshot_data = SnapshotPolicy.create(
self.apiclient, self.data_volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_data.id,
volumeid=self.data_volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
data_snap_to_delete = snapshots[0]
time.sleep((self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600)
data_snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(data_snap_to_delete not in data_snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0], "Destroyed")
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, data_snap_to_delete.id))
def test_03_volume_rec_snapshot(self):
""" Test Volume (root) Snapshot
# 1. For snapshot.delta.max > maxsnaps verify that when number of snapshot exceeds
maxsnaps value previous snapshot should get deleted from database but remain
on secondary storage and when the value exceeds snapshot.delta.max the
snapshot should get deleted from secondary storage
"""
if self.hypervisor.lower() != "xenserver":
self.skipTest("Skip test for hypervisor other than Xenserver")
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_root = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
Configurations.update(self.apiclient,
name="snapshot.delta.max",
value="3"
)
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_root.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
time.sleep(3600 * 2)
snapshots_2 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(snapshots[0] not in snapshots_2)
for snapshot in snapshots_2:
snapshots.append(snapshot)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[0].id)[0][0],
"Destroyed"
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshots[0].id))
time.sleep(3600)
snapshots_3 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(snapshots[1] not in snapshots_3)
snapshots.append(snapshots_3[1])
time.sleep(180)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[1].id)[0][0],
"Destroyed"
)
for snapshot in [snapshots[0], snapshots[1]]:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
time.sleep(3600)
snapshots_4 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(snapshots[2] not in snapshots_4)
snapshots.append(snapshots_4[1])
time.sleep(180)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[2].id)[0][0],
"Destroyed"
)
for snapshot in [snapshots[0], snapshots[1], snapshots[2]]:
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
return
def test_02_volume_max_snapshot(self):
""" Test Volume Snapshot
# 1. Create Hourly reccuring snapshot policy with maxsnaps=2
verify that when 3rd snapshot is taken first snapshot gets deleted
"""
if self.hypervisor.lower() not in ["kvm", "vmware"]:
self.skipTest("Skip test for hypervisor other than KVM and VMWare")
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_1 = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_1.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
snap_to_delete = snapshots[0]
time.sleep(
(self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600
)
snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(snap_to_delete not in snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0],
"Destroyed"
)
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snap_to_delete.id))
# DATA DISK
recurring_snapshot_data = SnapshotPolicy.create(
self.apiclient,
self.data_volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_data.id,
volumeid=self.data_volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
data_snap_to_delete = snapshots[0]
time.sleep(
(self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600
)
data_snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(data_snap_to_delete not in data_snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0],
"Destroyed"
)
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
data_snap_to_delete.id))
def test_01_volume_snapshot(self):
""" Test Volume (root) Snapshot
# 1. Create Hourly, Daily,Weekly recurring snapshot policy for ROOT disk and
Verify the presence of the corresponding snapshots on the Secondary Storage
# 2. Delete the snapshot policy and verify the entry as Destroyed in snapshot_schedule
# 3. Verify that maxsnaps should not consider manual snapshots for deletion
# 4. Snapshot policy should reflect the correct timezone
# 5. Verify that listSnapshotPolicies() should return all snapshot policies
that belong to the account (both manual and recurring snapshots)
# 6. Verify that listSnapshotPolicies() should not return snapshot
policies that have been deleted
# 7. Verify that snapshot should not be created for VM in Destroyed state
# 8. Verify that snapshot should get created after resuming the VM
# 9. Verify that All the recurring policies associated with the VM should be
deleted after VM get destroyed.
"""
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
recurring_snapshot = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
for snapshot in snapshots:
self.assertEqual(
self.dbclient.execute(
"select type_description from snapshots where name='%s'" %
snapshot.name)[0][0],
"HOURLY"
)
time.sleep(180)
for snapshot in snapshots:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
recurring_snapshot.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot.id),
[]
)
self.testdata["recurring_snapshot"]["intervaltype"] = 'DAILY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00'
recurring_snapshot_daily = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_daily = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_daily.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_daily)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
snap_db_daily = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_daily.id)
validation_result_1 = validateList(snap_db_daily)
self.assertEqual(
validation_result_1[0],
PASS,
"snapshot_policy list validation failed due to %s" %
validation_result_1[2])
self.assertNotEqual(
len(snap_db_daily),
0,
"Check DB Query result set"
)
recurring_snapshot_daily.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_daily.id),
[]
)
self.testdata["recurring_snapshot"]["intervaltype"] = 'WEEKLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_weekly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_weekly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_weekly.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_weekly)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
snap_sch_2 = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id)
validation_result_2 = validateList(snap_sch_2)
self.assertEqual(
validation_result_2[0],
PASS,
"snapshot_policy list validation failed due to %s" %
validation_result_2[2])
self.assertNotEqual(
len(snap_sch_2),
0,
"Check DB Query result set"
)
recurring_snapshot_weekly.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id),
[]
)
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_monthly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_monthly.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_monthly)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
snap_sch_3 = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_monthly.id)
validation_result = validateList(snap_sch_3)
self.assertEqual(
validation_result[0],
PASS,
"snapshot_policy list validation failed due to %s" %
validation_result[2])
self.assertNotEqual(
len(snap_sch_3),
0,
"Check DB Query result set"
)
recurring_snapshot_monthly.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id),
[]
)
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
# Step 3
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_1 = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_1.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
snap_to_delete = snapshots[0]
time.sleep(
(self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600
)
snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertTrue(snap_to_delete not in snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0],
"Destroyed"
)
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snap_to_delete.id))
# Step 4
recurring_snapshot = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(180)
snap_time_hourly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot.id)
self.debug("Timestamp for hourly snapshot %s" % snap_time_hourly)
recurring_snapshot.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'DAILY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00'
recurring_snapshot_daily = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_daily = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_daily.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_daily)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(180)
snap_time_daily = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_daily.id)
self.debug("Timestamp for daily snapshot %s" % snap_time_daily)
recurring_snapshot_daily.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'WEEKLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_weekly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_weekly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_weekly.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_weekly)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(180)
snap_time_weekly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_weekly.id)
self.debug("Timestamp for monthly snapshot %s" % snap_time_weekly)
recurring_snapshot_weekly.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy_monthly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_monthly.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy_monthly)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(180)
snap_time_monthly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_monthly.id)
self.debug("Timestamp for monthly snapshot %s" % snap_time_monthly)
recurring_snapshot_monthly.delete(self.apiclient)
# Step 5
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_hourly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
for rec in [recurring_snapshot_hourly, recurring_snapshot_monthly]:
self.assertTrue(
rec.id in any(
policy['id']) for policy in list_snapshots_policy)
recurring_snapshot_hourly.delete(self.apiclient)
recurring_snapshot_monthly.delete(self.apiclient)
# Step 6
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_hourly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
recurring_snapshot_monthly.delete(self.apiclient)
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
self.assertTrue(
recurring_snapshot_hourly.id in any(
policy['id']) for policy in list_snapshots_policy)
self.assertTrue(
recurring_snapshot_monthly.id not in any(
policy['id']) for policy in list_snapshots_policy)
# Step 7
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot = SnapshotPolicy.create(
self.apiclient,
self.volume[0].id,
self.testdata["recurring_snapshot"]
)
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id
)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata[
"recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
self.vm_1.delete(self.apiclient, expunge=False)
time.sleep(3600)
snapshot_list = Snapshot.list(
self.apiclient,
volumeid=self.volume[0].id
)
list_validation = validateList(snapshot_list)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
self.assertEqual(len(snapshot_list),
1,
"Verify that snapsot is not created after VM deletion"
)
# Step 8
self.vm_1.recover(self.apiclient)
time.sleep(3600)
snapshot_list = Snapshot.list(
self.apiclient,
volumeid=self.volume[0].id
)
self.assertEqual(len(snapshot_list),
2,
"Verify that snapsot is not created after VM deletion"
)
# Step 9
self.vm_1.delete(self.apiclient)
time.sleep(180)
with self.assertRaises(Exception):
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
volumeid=self.volume[0].id
)
def test_02_accountSnapshotClean(self):
"""Test snapshot cleanup after account deletion
"""
# Validate the following
# 1. listAccounts API should list out the newly created account
# 2. listVirtualMachines() command should return the deployed VM.
# State of this VM should be "Running"
# 3. a)listSnapshots should list the snapshot that was created.
# b)verify that secondary storage NFS share contains the reqd volume
# under /secondary/snapshots/$accountid/$volumeid/$snapshot_id
# 4. a)listAccounts should not list account that is deleted
# b) snapshot image($snapshot_id) should be deleted from the
# /secondary/snapshots/$accountid/$volumeid/
try:
accounts = list_accounts(
self.apiclient,
id=self.account.id
)
self.assertEqual(
isinstance(accounts, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(accounts),
0,
"Check list Accounts response"
)
# Verify the snapshot was created or not
snapshots = list_snapshots(
self.apiclient,
id=self.snapshot.id
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"No such snapshot %s found" % self.snapshot.id
)
self.assertEqual(
snapshots[0].id,
self.snapshot.id,
"Check snapshot id in list resources call"
)
self.assertTrue(is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config, self.zone.id, self.snapshot.id),
"Snapshot was not found on NFS")
except Exception as e:
self._cleanup.append(self.account)
self.fail("Exception occured: %s" % e)
self.debug("Deleting account: %s" % self.account.name)
# Delete account
self.account.delete(self.apiclient)
# Wait for account cleanup interval
wait_for_cleanup(self.apiclient, configs=["account.cleanup.interval"])
with self.assertRaises(Exception):
accounts = list_accounts(
self.apiclient,
id=self.account.id
)
self.assertFalse(is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config, self.zone.id, self.snapshot.id),
"Snapshot was still found on NFS after account gc")
return
def test_01_concurrent_snapshots(self):
"""Concurrent Snapshots
1. Create snapshot on 2 new VMs in parallel and check
1. all snapshot jobs are running
2. listSnapshots should list all the snapshots
3. Verify secondary_storage NFS share
contains the required volume under
/secondary/snapshots/$accountid/$volumeid/$snapshot_uuid.
4. Verify backup_snap_id was non null in "snapshots"table
2. Perform step 1 for all the 4 VM's.
3. Verify that VM gets migrated when snapshot
is in pregress for the VM.
4. Verify that snapshots get created when
VM's are stoped in between snapshot creation.
5. Perform live Migration then stop all the
VM's after that verify that snapshot creation success .
6. Verify success of snapshots creation in case:
Stop the running VM while performing
concurrent snapshot on volumes
7. Verify success of snapshots creation in case:
Start Migration of VM's and then Stop the running VM then
performing concurrent snapshot on volumes
"""
# Step 1
try:
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self, self.root_pool[0],
False))
create_snapshot_thread_2 = Thread(target=CreateSnapshot,
args=(self, self.root_pool[1],
False))
create_snapshot_thread_1.start()
create_snapshot_thread_2.start()
create_snapshot_thread_1.join()
create_snapshot_thread_2.join()
except:
self.debug("Error: unable to start thread")
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 2
thread_pool = []
for i in range(4):
try:
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" % e)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 3
# Recurring snapshot
try:
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self, self.root_pool[0],
True))
create_snapshot_thread_2 = Thread(target=CreateSnapshot,
args=(self, self.root_pool[1],
True))
create_snapshot_thread_1.start()
create_snapshot_thread_2.start()
create_snapshot_thread_1.join()
create_snapshot_thread_2.join()
except:
self.debug("Error: unable to start thread")
for rec_snap in self.rec_policy_pool:
list_snapshots_policy_1 = list_snapshot_policy(
self.apiclient,
id=rec_snap.id,
)
list_validation = validateList(list_snapshots_policy_1)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(self.sleep_time_for_hourly_policy)
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
for rec_snap_pol in self.rec_policy_pool:
rec_snap_pol.delete(self.apiclient)
self.rec_policy_pool = []
# Step 4
thread_pool = []
for i in range(4):
try:
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self,
self.root_pool[i],
True))
thread_pool.append(create_snapshot_thread_1)
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" % e)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
for rec_snap in self.rec_policy_pool:
list_snapshots_policy_1 = list_snapshot_policy(
self.apiclient,
id=rec_snap.id,
)
list_validation_1 = validateList(list_snapshots_policy_1)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" %
list_validation_1[2])
time.sleep(self.sleep_time_for_hourly_policy)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
for rec_snap_pol in self.rec_policy_pool:
rec_snap_pol.delete(self.apiclient)
self.rec_policy_pool = []
# Step 5
try:
thread_pool = []
for i in range(4):
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
destinationHost = Host.listForMigration(
self.apiclient, virtualmachineid=self.vm_pool[3].id)
migrate_volume_thread_1 = Thread(target=MigrateRootVolume,
args=(self, self.vm_pool[3],
destinationHost[0]))
thread_pool.append(migrate_volume_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except Exception as e:
raise Exception("Warning: Exception unable to start thread : %s" %
e)
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 6
try:
thread_pool = []
for i in range(4):
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
stop_vm_thread_1 = Thread(target=self.StopVM,
args=(self.vm_pool, ))
thread_pool.append(stop_vm_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except Exception as e:
raise Exception("Warning: Exception unable to start thread : %s" %
e)
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 7
thread_pool = []
try:
for i in range(2):
destinationHost = Host.listForMigration(
self.apiclient, virtualmachineid=self.vm_pool[i].id)
migrate_volume_thread_1 = Thread(target=MigrateRootVolume,
args=(self, self.vm_pool[i],
destinationHost[0]))
thread_pool.append(migrate_volume_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
for vm in self.vm_pool:
if vm.state != "Stopped":
vm.stop(self.apiclient)
thread_pool = []
for vm in self.vm_pool[:2]:
create_snapshot_thread_1 = Thread(target=CreateSnapshot,
args=(self,
self.root_pool[0],
False))
thread_pool.append(create_snapshot_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except:
self.debug("Error: unable to start thread")
snapshots = list_snapshots(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
def test_01_volume_snapshot(self):
""" Test Volume (root) Snapshot
# 1. Create Hourly, Daily,Weekly recurring snapshot policy for ROOT disk and
Verify the presence of the corresponding snapshots on the Secondary Storage
# 2. Delete the snapshot policy and verify the entry as Destroyed in snapshot_schedule
# 3. Verify that maxsnaps should not consider manual snapshots for deletion
# 4. Snapshot policy should reflect the correct timezone
# 5. Verify that listSnapshotPolicies() should return all snapshot policies
that belong to the account (both manual and recurring snapshots)
# 6. Verify that listSnapshotPolicies() should not return snapshot
policies that have been deleted
# 7. Verify that snapshot should not be created for VM in Destroyed state
# 8. Verify that snapshot should get created after resuming the VM
# 9. Verify that All the recurring policies associated with the VM should be
deleted after VM get destroyed.
"""
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
recurring_snapshot = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
for snapshot in snapshots:
self.assertEqual(
self.dbclient.execute(
"select type_description from snapshots where name='%s'" %
snapshot.name)[0][0], "HOURLY")
time.sleep(180)
for snapshot in snapshots:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
recurring_snapshot.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot.id), [])
self.testdata["recurring_snapshot"]["intervaltype"] = 'DAILY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00'
recurring_snapshot_daily = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_daily = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_daily.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_daily)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
snap_db_daily = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_daily.id)
validation_result_1 = validateList(snap_db_daily)
self.assertEqual(
validation_result_1[0], PASS,
"snapshot_policy list validation failed due to %s" %
validation_result_1[2])
self.assertNotEqual(len(snap_db_daily), 0, "Check DB Query result set")
recurring_snapshot_daily.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_daily.id), [])
self.testdata["recurring_snapshot"]["intervaltype"] = 'WEEKLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_weekly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_weekly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_weekly.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_weekly)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
snap_sch_2 = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id)
validation_result_2 = validateList(snap_sch_2)
self.assertEqual(
validation_result_2[0], PASS,
"snapshot_policy list validation failed due to %s" %
validation_result_2[2])
self.assertNotEqual(len(snap_sch_2), 0, "Check DB Query result set")
recurring_snapshot_weekly.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id), [])
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_monthly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_monthly.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_monthly)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
snap_sch_3 = self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_monthly.id)
validation_result = validateList(snap_sch_3)
self.assertEqual(
validation_result[0], PASS,
"snapshot_policy list validation failed due to %s" %
validation_result[2])
self.assertNotEqual(len(snap_sch_3), 0, "Check DB Query result set")
recurring_snapshot_monthly.delete(self.apiclient)
self.assertEqual(
self.dbclient.execute(
"select * from snapshot_policy where uuid='%s'" %
recurring_snapshot_weekly.id), [])
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
# Step 3
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_1 = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_1.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
snap_to_delete = snapshots[0]
time.sleep((self.testdata["recurring_snapshot"]["maxsnaps"]) * 3600)
snapshots_1 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(snap_to_delete not in snapshots_1)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snap_to_delete.id)[0][0], "Destroyed")
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snap_to_delete.id))
# Step 4
recurring_snapshot = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
time.sleep(180)
snap_time_hourly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" % recurring_snapshot.id)
self.debug("Timestamp for hourly snapshot %s" % snap_time_hourly)
recurring_snapshot.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'DAILY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00'
recurring_snapshot_daily = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_daily = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_daily.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_daily)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
time.sleep(180)
snap_time_daily = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_daily.id)
self.debug("Timestamp for daily snapshot %s" % snap_time_daily)
recurring_snapshot_daily.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'WEEKLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_weekly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_weekly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_weekly.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_weekly)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
time.sleep(180)
snap_time_weekly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_weekly.id)
self.debug("Timestamp for monthly snapshot %s" % snap_time_weekly)
recurring_snapshot_weekly.delete(self.apiclient)
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy_monthly = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_monthly.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy_monthly)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
time.sleep(180)
snap_time_monthly = self.dbclient.execute(
"select scheduled_timestamp from \
snapshot_schedule where uuid='%s'" %
recurring_snapshot_monthly.id)
self.debug("Timestamp for monthly snapshot %s" % snap_time_monthly)
recurring_snapshot_monthly.delete(self.apiclient)
# Step 5
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_hourly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
list_snapshots_policy = list_snapshot_policy(
self.apiclient, volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
for rec in [recurring_snapshot_hourly, recurring_snapshot_monthly]:
self.assertTrue(rec.id in any(policy['id'])
for policy in list_snapshots_policy)
recurring_snapshot_hourly.delete(self.apiclient)
recurring_snapshot_monthly.delete(self.apiclient)
# Step 6
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_hourly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
self.testdata["recurring_snapshot"]["intervaltype"] = 'MONTHLY'
self.testdata["recurring_snapshot"]["schedule"] = '00:00:1'
recurring_snapshot_monthly = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
recurring_snapshot_monthly.delete(self.apiclient)
list_snapshots_policy = list_snapshot_policy(
self.apiclient, volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
self.assertTrue(recurring_snapshot_hourly.id in any(policy['id'])
for policy in list_snapshots_policy)
self.assertTrue(recurring_snapshot_monthly.id not in any(policy['id'])
for policy in list_snapshots_policy)
# Step 7
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
# ListSnapshotPolicy should return newly created policy
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
self.vm_1.delete(self.apiclient, expunge=False)
time.sleep(3600)
snapshot_list = Snapshot.list(self.apiclient,
volumeid=self.volume[0].id)
list_validation = validateList(snapshot_list)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
self.assertEqual(
len(snapshot_list), 1,
"Verify that snapsot is not created after VM deletion")
# Step 8
self.vm_1.recover(self.apiclient)
time.sleep(3600)
snapshot_list = Snapshot.list(self.apiclient,
volumeid=self.volume[0].id)
self.assertEqual(
len(snapshot_list), 2,
"Verify that snapsot is not created after VM deletion")
# Step 9
self.vm_1.delete(self.apiclient)
time.sleep(180)
with self.assertRaises(Exception):
list_snapshots_policy = list_snapshot_policy(
self.apiclient, volumeid=self.volume[0].id)
def test_01_snapshot_root_disk(self):
"""Test Snapshot Root Disk
"""
# Validate the following
# 1. listSnapshots should list the snapshot that was created.
# 2. verify that secondary storage NFS share contains
# the reqd volume under
# /secondary/snapshots//$account_id/$volumeid/$snapshot_uuid
# 3. verify backup_snap_id was non null in the `snapshots` table
# 4. Verify that zoneid is returned in listSnapshots API response
volumes = list_volumes(
self.apiclient,
virtualmachineid=self.virtual_machine_with_disk.id,
type='ROOT',
listall=True
)
snapshot = Snapshot.create(
self.apiclient,
volumes[0].id,
account=self.account.name,
domainid=self.account.domainid
)
self.debug("Snapshot created: ID - %s" % snapshot.id)
snapshots = list_snapshots(
self.apiclient,
id=snapshot.id
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"Check if result exists in list item call"
)
self.assertEqual(
snapshots[0].id,
snapshot.id,
"Check resource id in list resources call"
)
self.assertIsNotNone(snapshots[0].zoneid,
"Zone id is not none in listSnapshots")
self.assertEqual(
snapshots[0].zoneid,
self.zone.id,
"Check zone id in the list snapshots"
)
self.debug(
"select backup_snap_id, account_id, volume_id from snapshots where uuid = '%s';"
% str(snapshot.id)
)
qresultset = self.dbclient.execute(
"select backup_snap_id, account_id, volume_id from snapshots where uuid = '%s';"
% str(snapshot.id)
)
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
qresult = qresultset[0]
snapshot_uuid = qresult[0] # backup_snap_id = snapshot UUID
self.assertNotEqual(
str(snapshot_uuid),
'NULL',
"Check if backup_snap_id is not null"
)
self.assertTrue(is_snapshot_on_nfs(
self.apiclient, self.dbclient, self.config, self.zone.id, snapshot.id))
return
def test_01_snapshot_on_rootVolume(self):
"""Test create VM with default cent os template and create snapshot
on root disk of the vm
"""
# Validate the following
# 1. Deploy a Linux VM using default CentOS template, use small service
# offering, disk offering
# 2. Create snapshot on the root disk of this newly cteated vm
# 3. listSnapshots should list the snapshot that was created.
# 4. verify that secondary storage NFS share contains the reqd
# volume under /secondary/snapshots/$accountid/$volumeid/$snapshot_uuid
# 5. verify backup_snap_id was non null in the `snapshots` table
# Create virtual machine with small systerm offering and disk offering
new_virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
diskofferingid=self.disk_offering.id,
)
self.debug("Virtual machine got created with id: %s" %
new_virtual_machine.id)
list_virtual_machine_response = VirtualMachine.list(
self.apiclient,
id=new_virtual_machine.id)
self.assertEqual(isinstance(list_virtual_machine_response, list),
True,
"Check listVirtualMachines returns a valid list")
self.assertNotEqual(len(list_virtual_machine_response),
0,
"Check listVirtualMachines response")
self.cleanup.append(new_virtual_machine)
# Getting root volume id of the vm created above
list_volume_response = Volume.list(
self.apiclient,
virtualmachineid=list_virtual_machine_response[0].id,
type="ROOT",
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_volume_response, list),
True,
"Check listVolumes returns a valid list")
self.assertNotEqual(len(list_volume_response),
0,
"Check listVolumes response")
self.debug(
"Snapshot will be created on the volume with voluem id: %s" %
list_volume_response[0].id)
# Perform snapshot on the root volume
root_volume_snapshot = Snapshot.create(
self.apiclient,
volume_id=list_volume_response[0].id)
self.debug("Created snapshot: %s for vm: %s" % (
root_volume_snapshot.id,
list_virtual_machine_response[0].id))
list_snapshot_response = Snapshot.list(
self.apiclient,
id=root_volume_snapshot.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_snapshot_response, list),
True,
"Check listSnapshots returns a valid list")
self.assertNotEqual(len(list_snapshot_response),
0,
"Check listSnapshots response")
# Verify Snapshot state
self.assertEqual(
list_snapshot_response[0].state in [
'BackedUp',
'CreatedOnPrimary'
],
True,
"Snapshot state is not as expected. It is %s" %
list_snapshot_response[0].state
)
self.assertEqual(
list_snapshot_response[0].volumeid,
list_volume_response[0].id,
"Snapshot volume id is not matching with the vm's volume id")
self.cleanup.append(root_volume_snapshot)
# Below code is to verify snapshots in the backend and in db.
# Verify backup_snap_id field in the snapshots table for the snapshot created, it should not be null
self.debug("select id, removed, backup_snap_id from snapshots where uuid = '%s';" % root_volume_snapshot.id)
qryresult = self.dbclient.execute("select id, removed, backup_snap_id from snapshots where uuid = '%s';" % root_volume_snapshot.id)
self.assertNotEqual(len(qryresult), 0, "Check sql query to return snapshots list")
snapshot_qry_response = qryresult[0]
snapshot_id = snapshot_qry_response[0]
is_removed = snapshot_qry_response[1]
backup_snap_id = snapshot_qry_response[2]
self.assertNotEqual(is_removed, "NULL", "Snapshot is removed from CS, please check the logs")
msg = "Backup snapshot id is set to null for the backedup snapshot :%s" % snapshot_id
self.assertNotEqual(backup_snap_id, "NULL", msg )
# Check if the snapshot is present on the secondary storage
self.assertTrue(is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config, self.zone.id, root_volume_snapshot.id))
return
def test_01_volume_snapshot(self):
""" Test Volume (root) Snapshot
# 1. Deploy a VM on primary storage and .
# 2. Take snapshot on root disk
# 3. Verify the snapshot's entry in the "snapshots" table
and presence of the corresponding
snapshot on the Secondary Storage
# 4. Create Template from the Snapshot and Deploy a
VM using the Template
# 5. Log in to the VM from template and make verify
the contents of the ROOT disk matches with the snapshot.
# 6. Delete Snapshot and Deploy a Linux VM from the
Template and verify the successful deployment of the VM.
# 7. Create multiple snapshots on the same volume and
Check the integrity of all the snapshots by creating
a template from the snapshot and deploying a Vm from it
and delete one of the snapshots
# 8. Verify that the original checksum matches with the checksum
of VM's created from remaning snapshots
# 9. Make verify the contents of the ROOT disk
matches with the snapshot
# 10.Verify that Snapshot of both DATA and ROOT volume should
succeed when snapshot of Data disk of a VM is taken
when snapshot of ROOT volume of VM is in progress
# 11.Create snapshot of data disk and verify the original checksum
matches with the volume created from snapshot
# 12.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is attached to a VM
# 13.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is not attached to a VM
# 14.Verify that create Snapshot with quiescevm=True should succeed
# 15.revertSnapshot() to revert VM to a specified
Volume snapshot for root volume
"""
# Step 1
# Get ROOT Volume Id
root_volumes_cluster_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_1.id,
type='ROOT',
listall=True)
root_volume_cluster = root_volumes_cluster_list[0]
disk_volumes_cluster_list = list_volumes(self.apiclient,
virtualmachineid=self.vm_1.id,
type='DATADISK',
listall=True)
data_disk = disk_volumes_cluster_list[0]
root_vol_state = root_volume_cluster.state
ckecksum_random_root_cluster = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap = Snapshot.create(self.apiclient, root_volume_cluster.id)
self.assertEqual(root_vol_snap.state, "BackedUp",
"Check if the snapshot state is correct ")
self.assertEqual(root_vol_state, root_volume_cluster.state,
"Check if volume state has changed")
self.vm_1.start(self.apiclient)
# Step 2
snapshot_list = list_snapshots(self.apiclient, id=root_vol_snap.id)
self.assertNotEqual(snapshot_list, None,
"Check if result exists in list item call")
self.assertEqual(snapshot_list[0].id, root_vol_snap.id,
"Check resource id in list resources call")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, root_vol_snap.id))
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.CREATE' AND \
description like '%%%s%%' AND state='Completed';" %
root_volume_cluster.id)
event_validation_result = validateList(qresultset)
self.assertEqual(
event_validation_result[0], PASS,
"event list validation failed due to %s" %
event_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.CREATE') > 0, True,
"Check SNAPSHOT.CREATE event in events table")
#Usage_Event
qresultset = self.dbclient.execute(
"select * from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" % root_vol_snap.name)
usage_event_validation_result = validateList(qresultset)
self.assertEqual(
usage_event_validation_result[0], PASS,
"event list validation failed due to %s" %
usage_event_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
self.assertEqual(
self.dbclient.execute(
"select size from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" % root_vol_snap.name)[0][0],
root_vol_snap.physicalsize)
# Step 3
# create template from snapshot root_vol_snap
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
vm_from_temp.delete(self.apiclient)
# Step 4
root_vol_snap.delete(self.userapiclient)
self.assertEqual(
list_snapshots(
self.apiclient,
volumeid=root_volume_cluster.id,
), None, "Snapshot list should be empty")
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.DELETE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.DELETE")
self.debug("select id from account where uuid = '%s';" %
self.account.id)
qresultset = self.dbclient.execute(
"select id from account where uuid = '%s';" % self.account.id)
account_validation_result = validateList(qresultset)
self.assertEqual(
account_validation_result[0], PASS,
"event list validation failed due to %s" %
account_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = qresultset[0]
account_id = qresult[0]
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.DELETE' AND \
account_id='%s' AND state='Completed';" % account_id)
delete_snap_validation_result = validateList(qresultset)
self.assertEqual(
delete_snap_validation_result[0], PASS,
"event list validation failed due to %s" %
delete_snap_validation_result[2])
self.assertNotEqual(len(qresultset), 0, "Check DB Query result set")
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.DELETE') > 0, True,
"Check SNAPSHOT.DELETE event in events table")
# Step 5
# delete snapshot and deploy vm from snapshot
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp_2, None,
"Check if result exists in list item call")
# Step 6:
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2)
vm_from_temp_2.delete(self.apiclient)
# Step 7
# Multiple Snapshots
self.vm_1.stop(self.apiclient)
snaps = []
for i in range(2):
root_vol_snap = Snapshot.create(self.apiclient,
root_volume_cluster.id)
self.assertEqual(
root_vol_snap.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
snaps.append(root_vol_snap)
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
vm_from_temp.delete(self.apiclient)
templateFromSnapshot.delete(self.apiclient)
self.vm_1.start(self.apiclient)
delete_snap = snaps.pop(1)
delete_snap.delete(self.apiclient)
self.assertEqual(Snapshot.list(self.apiclient, id=delete_snap.id),
None, "Snapshot list should be empty")
# Step 8
for snap in snaps:
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, snap, self.testdata["template_2"])
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp)
templateFromSnapshot.delete(self.apiclient)
vm_from_temp.delete(self.apiclient)
for snap in snaps:
snap.delete(self.apiclient)
# Step 9
ckecksum_root_cluster = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap_2 = Snapshot.create(self.apiclient,
root_volume_cluster.id)
self.assertEqual(root_vol_snap_2.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
snap_list_validation_result = validateList(events)
self.assertEqual(
snap_list_validation_result[0], PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
self.assertNotEqual(snapshot_list, None,
"Check if result exists in list item call")
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient, root_vol_snap_2, self.testdata["template_2"])
self.debug("create template event comlites with template %s name" %
templateFromSnapshot.name)
self.assertNotEqual(templateFromSnapshot, None,
"Check if result exists in list item call")
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
self.assertNotEqual(vm_from_temp_2, None,
"Check if result exists in list item call")
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2)
vm_from_temp_2.delete(self.apiclient)
# Step 10
# Take snapshot of Data disk of a VM , when snapshot of ROOT volume of
# VM is in progress
try:
self.vm_1.stop(self.apiclient)
t1 = Thread(target=Snapshot.create,
args=(self.apiclient, root_volume_cluster.id))
t2 = Thread(target=Snapshot.create,
args=(self.apiclient, data_disk.id))
t1.start()
t2.start()
t1.join()
t2.join()
except:
self.debug("Error: unable to start thread")
# Step 11
# Data Disk
self.vm_1.start(self.apiclient)
ckecksum_data_disk = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk,
disk_type="datadiskdevice_1")
data_vol_state = data_disk.state
self.vm_1.stop(self.apiclient)
data_vol_snap = Snapshot.create(self.apiclient, data_disk.id)
self.assertEqual(data_vol_snap.state, "BackedUp",
"Check if the data vol snapshot state is correct ")
self.assertEqual(data_vol_state, data_disk.state,
"Check if volume state has changed")
data_snapshot_list = list_snapshots(self.apiclient,
id=data_vol_snap.id)
self.assertNotEqual(data_snapshot_list, None,
"Check if result exists in list item call")
self.assertEqual(data_snapshot_list[0].id, data_vol_snap.id,
"Check resource id in list resources call")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, data_vol_snap.id))
events = list_events(self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0], PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
volumeFromSnap = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id)
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, data_vol_snap.id))
new_vm = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype)
new_vm.attach_volume(self.apiclient, volumeFromSnap)
new_vm.reboot(self.apiclient)
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=ckecksum_data_disk,
disk_type="datadiskdevice_1",
virt_machine=new_vm)
# Step 12
data_volume_2 = Volume.create(self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id)
self.vm_1.start(self.apiclient)
self.vm_1.attach_volume(self.userapiclient, data_volume_2)
self.vm_1.reboot(self.apiclient)
self.vm_1.stop(self.apiclient)
data_vol_snap_1 = Snapshot.create(self.apiclient, data_volume_2.id)
self.assertEqual(data_vol_snap_1.state, "BackedUp",
"Check if the snapshot state is correct ")
data_disk_2_list = Volume.list(self.userapiclient,
listall=self.testdata["listall"],
id=data_volume_2.id)
self.vm_1.start(self.apiclient)
checksum_data_2 = createChecksum(service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk_2_list[0],
disk_type="datadiskdevice_2")
# Step 13
self.vm_1.detach_volume(self.apiclient, data_volume_2)
self.vm_1.reboot(self.apiclient)
prev_state = data_volume_2.state
data_vol_snap_2 = Snapshot.create(self.apiclient, data_volume_2.id)
self.assertEqual(data_vol_snap_2.state, prev_state,
"Check if the volume state is correct ")
data_snapshot_list_2 = list_snapshots(self.apiclient,
id=data_vol_snap_2.id)
self.assertNotEqual(data_snapshot_list_2, None,
"Check if result exists in list item call")
self.assertEqual(data_snapshot_list_2[0].id, data_vol_snap_2.id,
"Check resource id in list resources call")
volumeFromSnap_2 = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap_2.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id)
self.vm_2.attach_volume(self.userapiclient, volumeFromSnap_2)
self.vm_2.reboot(self.apiclient)
data_disk_2_list = Volume.list(self.userapiclient,
listall=self.testdata["listall"],
id=volumeFromSnap_2.id)
compareChecksum(self.apiclient,
service=self.testdata,
original_checksum=checksum_data_2,
disk_type="datadiskdevice_2",
virt_machine=self.vm_2)
# Step 14
self.vm_1.stop(self.apiclient)
with self.assertRaises(Exception):
root_vol_snap.revertVolToSnapshot(self.apiclient)
# Step 15
root_snap = Snapshot.create(self.apiclient, root_volume_cluster.id)
with self.assertRaises(Exception):
root_snap.revertVolToSnapshot(self.apiclient)
return
def test_03_volume_rec_snapshot(self):
""" Test Volume (root) Snapshot
# 1. For snapshot.delta.max > maxsnaps verify that when number of snapshot exceeds
maxsnaps value previous snapshot should get deleted from database but remain
on secondary storage and when the value exceeds snapshot.delta.max the
snapshot should get deleted from secondary storage
"""
if self.hypervisor.lower() != "xenserver":
self.skipTest("Skip test for hypervisor other than Xenserver")
# Step 1
self.testdata["recurring_snapshot"]["intervaltype"] = 'HOURLY'
self.testdata["recurring_snapshot"]["schedule"] = 1
recurring_snapshot_root = SnapshotPolicy.create(
self.apiclient, self.volume[0].id,
self.testdata["recurring_snapshot"])
Configurations.update(self.apiclient,
name="snapshot.delta.max",
value="3")
list_snapshots_policy = list_snapshot_policy(
self.apiclient,
id=recurring_snapshot_root.id,
volumeid=self.volume[0].id)
list_validation = validateList(list_snapshots_policy)
self.assertEqual(
list_validation[0], PASS,
"snapshot list validation failed due to %s" % list_validation[2])
timeout = self.testdata["timeout"]
while True:
snapshots = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]
["intervaltype"],
snapshottype='RECURRING',
listall=True)
if isinstance(snapshots, list):
break
elif timeout == 0:
raise Exception("List snapshots API call failed.")
time.sleep(3600 * 2)
snapshots_2 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(snapshots[0] not in snapshots_2)
for snapshot in snapshots_2:
snapshots.append(snapshot)
time.sleep(360)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[0].id)[0][0], "Destroyed")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshots[0].id))
time.sleep(3600)
snapshots_3 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(snapshots[1] not in snapshots_3)
snapshots.append(snapshots_3[1])
time.sleep(180)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[1].id)[0][0], "Destroyed")
for snapshot in [snapshots[0], snapshots[1]]:
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
time.sleep(3600)
snapshots_4 = list_snapshots(
self.apiclient,
volumeid=self.volume[0].id,
intervaltype=self.testdata["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True)
self.assertTrue(snapshots[2] not in snapshots_4)
snapshots.append(snapshots_4[1])
time.sleep(180)
self.assertEqual(
self.dbclient.execute(
"select status from snapshots where uuid='%s'" %
snapshots[2].id)[0][0], "Destroyed")
for snapshot in [snapshots[0], snapshots[1], snapshots[2]]:
self.assertFalse(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
return
def test_01_concurrent_snapshots(self):
"""Concurrent Snapshots
1. Create snapshot on 2 new VMs in parallel and check
1. all snapshot jobs are running
2. listSnapshots should list all the snapshots
3. Verify secondary_storage NFS share
contains the required volume under
/secondary/snapshots/$accountid/$volumeid/$snapshot_uuid.
4. Verify backup_snap_id was non null in "snapshots"table
2. Perform step 1 for all the 4 VM's.
3. Verify that VM gets migrated when snapshot
is in pregress for the VM.
4. Verify that snapshots get created when
VM's are stoped in between snapshot creation.
5. Perform live Migration then stop all the
VM's after that verify that snapshot creation success .
6. Verify success of snapshots creation in case:
Stop the running VM while performing
concurrent snapshot on volumes
7. Verify success of snapshots creation in case:
Start Migration of VM's and then Stop the running VM then
performing concurrent snapshot on volumes
"""
# Step 1
try:
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[0],
False))
create_snapshot_thread_2 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[1],
False))
create_snapshot_thread_1.start()
create_snapshot_thread_2.start()
create_snapshot_thread_1.join()
create_snapshot_thread_2.join()
except:
self.debug("Error: unable to start thread")
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 2
thread_pool = []
for i in range(4):
try:
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" %
e)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 3
# Recurring snapshot
try:
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[0],
True))
create_snapshot_thread_2 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[1],
True))
create_snapshot_thread_1.start()
create_snapshot_thread_2.start()
create_snapshot_thread_1.join()
create_snapshot_thread_2.join()
except:
self.debug("Error: unable to start thread")
for rec_snap in self.rec_policy_pool:
list_snapshots_policy_1 = list_snapshot_policy(
self.apiclient,
id=rec_snap.id,
)
list_validation = validateList(list_snapshots_policy_1)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation[2])
time.sleep(self.sleep_time_for_hourly_policy)
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
for rec_snap_pol in self.rec_policy_pool:
rec_snap_pol.delete(self.apiclient)
self.rec_policy_pool = []
# Step 4
thread_pool = []
for i in range(4):
try:
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[i],
True))
thread_pool.append(create_snapshot_thread_1)
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" %
e)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
for rec_snap in self.rec_policy_pool:
list_snapshots_policy_1 = list_snapshot_policy(
self.apiclient,
id=rec_snap.id,
)
list_validation_1 = validateList(list_snapshots_policy_1)
self.assertEqual(
list_validation[0],
PASS,
"snapshot list validation failed due to %s" %
list_validation_1[2])
time.sleep(self.sleep_time_for_hourly_policy)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
for rec_snap_pol in self.rec_policy_pool:
rec_snap_pol.delete(self.apiclient)
self.rec_policy_pool = []
# Step 5
try:
thread_pool = []
for i in range(4):
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
destinationHost = Host.listForMigration(
self.apiclient,
virtualmachineid=self.vm_pool[3].id)
migrate_volume_thread_1 = Thread(target=MigrateRootVolume,
args=(self,
self.vm_pool[3],
destinationHost[0]))
thread_pool.append(migrate_volume_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" %
e)
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 6
try:
thread_pool = []
for i in range(4):
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[i],
False))
thread_pool.append(create_snapshot_thread_1)
stop_vm_thread_1 = Thread(target=self.StopVM,
args=(self.vm_pool,
))
thread_pool.append(stop_vm_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except Exception as e:
raise Exception(
"Warning: Exception unable to start thread : %s" %
e)
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
# Step 7
thread_pool = []
try:
for i in range(2):
destinationHost = Host.listForMigration(
self.apiclient,
virtualmachineid=self.vm_pool[i].id)
migrate_volume_thread_1 = Thread(target=MigrateRootVolume,
args=(self,
self.vm_pool[i],
destinationHost[0]))
thread_pool.append(migrate_volume_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
for vm in self.vm_pool:
if vm.state != "Stopped":
vm.stop(self.apiclient)
thread_pool = []
for vm in self.vm_pool[:2]:
create_snapshot_thread_1 = Thread(
target=CreateSnapshot,
args=(
self,
self.root_pool[0],
False))
thread_pool.append(create_snapshot_thread_1)
for thread in thread_pool:
thread.start()
for thread in thread_pool:
thread.join()
except:
self.debug("Error: unable to start thread")
snapshots = list_snapshots(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
listall=True
)
for snapshot in self.snapshot_pool:
self.assertTrue(snapshot.id in any(
s.id) for s in snapshots)
for snapshot in self.snapshot_pool:
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
for snapshot in self.snapshot_pool:
snapshot.delete(self.apiclient)
self.snapshot_pool = []
def test_01_volume_snapshot(self):
""" Test Volume (root) Snapshot
# 1. Deploy a VM on primary storage and .
# 2. Take snapshot on root disk
# 3. Verify the snapshot's entry in the "snapshots" table
and presence of the corresponding
snapshot on the Secondary Storage
# 4. Create Template from the Snapshot and Deploy a
VM using the Template
# 5. Log in to the VM from template and make verify
the contents of the ROOT disk matches with the snapshot.
# 6. Delete Snapshot and Deploy a Linux VM from the
Template and verify the successful deployment of the VM.
# 7. Create multiple snapshots on the same volume and
Check the integrity of all the snapshots by creating
a template from the snapshot and deploying a Vm from it
and delete one of the snapshots
# 8. Verify that the original checksum matches with the checksum
of VM's created from remaning snapshots
# 9. Make verify the contents of the ROOT disk
matches with the snapshot
# 10.Verify that Snapshot of both DATA and ROOT volume should
succeed when snapshot of Data disk of a VM is taken
when snapshot of ROOT volume of VM is in progress
# 11.Create snapshot of data disk and verify the original checksum
matches with the volume created from snapshot
# 12.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is attached to a VM
# 13.Verify that volume's state should not change when snapshot of
a DATA volume is taken that is not attached to a VM
# 14.Verify that create Snapshot with quiescevm=True should succeed
# 15.revertSnapshot() to revert VM to a specified
Volume snapshot for root volume
"""
# Step 1
# Get ROOT Volume Id
root_volumes_cluster_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm_1.id,
type='ROOT',
listall=True
)
root_volume_cluster = root_volumes_cluster_list[0]
disk_volumes_cluster_list = list_volumes(
self.apiclient,
virtualmachineid=self.vm_1.id,
type='DATADISK',
listall=True
)
data_disk = disk_volumes_cluster_list[0]
root_vol_state = root_volume_cluster.state
ckecksum_random_root_cluster = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap = Snapshot.create(
self.apiclient,
root_volume_cluster.id)
self.assertEqual(
root_vol_snap.state,
"BackedUp",
"Check if the snapshot state is correct "
)
self.assertEqual(
root_vol_state,
root_volume_cluster.state,
"Check if volume state has changed"
)
self.vm_1.start(self.apiclient)
# Step 2
snapshot_list = list_snapshots(
self.apiclient,
id=root_vol_snap.id
)
self.assertNotEqual(
snapshot_list,
None,
"Check if result exists in list item call"
)
self.assertEqual(
snapshot_list[0].id,
root_vol_snap.id,
"Check resource id in list resources call"
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
root_vol_snap.id))
events = list_events(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0],
PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.CREATE' AND \
description like '%%%s%%' AND state='Completed';" %
root_volume_cluster.id)
event_validation_result = validateList(qresultset)
self.assertEqual(
event_validation_result[0],
PASS,
"event list validation failed due to %s" %
event_validation_result[2])
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.CREATE') > 0,
True,
"Check SNAPSHOT.CREATE event in events table"
)
#Usage_Event
qresultset = self.dbclient.execute(
"select * from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" %
root_vol_snap.name)
usage_event_validation_result = validateList(qresultset)
self.assertEqual(
usage_event_validation_result[0],
PASS,
"event list validation failed due to %s" %
usage_event_validation_result[2])
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
self.assertEqual(
self.dbclient.execute("select size from usage_event where type='SNAPSHOT.CREATE' AND \
resource_name='%s'" %
root_vol_snap.name)[0][0],
root_vol_snap.physicalsize)
# Step 3
# create template from snapshot root_vol_snap
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient,
root_vol_snap,
self.testdata["template_2"])
self.assertNotEqual(
templateFromSnapshot,
None,
"Check if result exists in list item call"
)
vm_from_temp = VirtualMachine.create(
self.apiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
self.assertNotEqual(
vm_from_temp,
None,
"Check if result exists in list item call"
)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp
)
vm_from_temp.delete(self.apiclient)
# Step 4
root_vol_snap.delete(self.userapiclient)
self.assertEqual(
list_snapshots(
self.apiclient,
volumeid=root_volume_cluster.id,
), None, "Snapshot list should be empty")
events = list_events(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.DELETE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0],
PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.DELETE")
self.debug("select id from account where uuid = '%s';"
% self.account.id)
qresultset = self.dbclient.execute(
"select id from account where uuid = '%s';"
% self.account.id
)
account_validation_result = validateList(qresultset)
self.assertEqual(
account_validation_result[0],
PASS,
"event list validation failed due to %s" %
account_validation_result[2])
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
qresult = qresultset[0]
account_id = qresult[0]
qresultset = self.dbclient.execute(
"select * from event where type='SNAPSHOT.DELETE' AND \
account_id='%s' AND state='Completed';" %
account_id)
delete_snap_validation_result = validateList(qresultset)
self.assertEqual(
delete_snap_validation_result[0],
PASS,
"event list validation failed due to %s" %
delete_snap_validation_result[2])
self.assertNotEqual(
len(qresultset),
0,
"Check DB Query result set"
)
qresult = str(qresultset)
self.assertEqual(
qresult.count('SNAPSHOT.DELETE') > 0,
True,
"Check SNAPSHOT.DELETE event in events table"
)
# Step 5
# delete snapshot and deploy vm from snapshot
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
self.assertNotEqual(
vm_from_temp_2,
None,
"Check if result exists in list item call"
)
# Step 6:
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2
)
vm_from_temp_2.delete(self.apiclient)
# Step 7
# Multiple Snapshots
self.vm_1.stop(self.apiclient)
snaps = []
for i in range(2):
root_vol_snap = Snapshot.create(
self.apiclient,
root_volume_cluster.id)
self.assertEqual(
root_vol_snap.state,
"BackedUp",
"Check if the data vol snapshot state is correct "
)
snaps.append(root_vol_snap)
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient,
root_vol_snap,
self.testdata["template_2"])
self.assertNotEqual(
templateFromSnapshot,
None,
"Check if result exists in list item call"
)
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
self.assertNotEqual(
vm_from_temp,
None,
"Check if result exists in list item call"
)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp
)
vm_from_temp.delete(self.apiclient)
templateFromSnapshot.delete(self.apiclient)
self.vm_1.start(self.apiclient)
delete_snap = snaps.pop(1)
delete_snap.delete(self.apiclient)
self.assertEqual(
Snapshot.list(
self.apiclient,
id=delete_snap.id
), None, "Snapshot list should be empty")
# Step 8
for snap in snaps:
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient,
snap,
self.testdata["template_2"])
self.assertNotEqual(
templateFromSnapshot,
None,
"Check if result exists in list item call"
)
vm_from_temp = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
self.assertNotEqual(
vm_from_temp,
None,
"Check if result exists in list item call"
)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_random_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp
)
templateFromSnapshot.delete(self.apiclient)
vm_from_temp.delete(self.apiclient)
for snap in snaps:
snap.delete(self.apiclient)
# Step 9
ckecksum_root_cluster = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=root_volume_cluster,
disk_type="rootdiskdevice")
self.vm_1.stop(self.apiclient)
root_vol_snap_2 = Snapshot.create(
self.apiclient,
root_volume_cluster.id)
self.assertEqual(
root_vol_snap_2.state,
"BackedUp",
"Check if the data vol snapshot state is correct "
)
snap_list_validation_result = validateList(events)
self.assertEqual(
snap_list_validation_result[0],
PASS,
"snapshot list validation failed due to %s" %
snap_list_validation_result[2])
self.assertNotEqual(
snapshot_list,
None,
"Check if result exists in list item call"
)
templateFromSnapshot = Template.create_from_snapshot(
self.apiclient,
root_vol_snap_2,
self.testdata["template_2"])
self.debug(
"create template event comlites with template %s name" %
templateFromSnapshot.name)
self.assertNotEqual(
templateFromSnapshot,
None,
"Check if result exists in list item call"
)
vm_from_temp_2 = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=templateFromSnapshot.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
self.assertNotEqual(
vm_from_temp_2,
None,
"Check if result exists in list item call"
)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_root_cluster,
disk_type="rootdiskdevice",
virt_machine=vm_from_temp_2
)
vm_from_temp_2.delete(self.apiclient)
# Step 10
# Take snapshot of Data disk of a VM , when snapshot of ROOT volume of
# VM is in progress
try:
self.vm_1.stop(self.apiclient)
t1 = Thread(
target=Snapshot.create,
args=(
self.apiclient,
root_volume_cluster.id
))
t2 = Thread(
target=Snapshot.create,
args=(
self.apiclient,
data_disk.id
))
t1.start()
t2.start()
t1.join()
t2.join()
except:
self.debug("Error: unable to start thread")
# Step 11
# Data Disk
self.vm_1.start(self.apiclient)
ckecksum_data_disk = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk,
disk_type="datadiskdevice_1")
data_vol_state = data_disk.state
self.vm_1.stop(self.apiclient)
data_vol_snap = Snapshot.create(
self.apiclient,
data_disk.id)
self.assertEqual(
data_vol_snap.state,
"BackedUp",
"Check if the data vol snapshot state is correct "
)
self.assertEqual(
data_vol_state,
data_disk.state,
"Check if volume state has changed"
)
data_snapshot_list = list_snapshots(
self.apiclient,
id=data_vol_snap.id
)
self.assertNotEqual(
data_snapshot_list,
None,
"Check if result exists in list item call"
)
self.assertEqual(
data_snapshot_list[0].id,
data_vol_snap.id,
"Check resource id in list resources call"
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
data_vol_snap.id))
events = list_events(
self.apiclient,
account=self.account.name,
domainid=self.account.domainid,
type='SNAPSHOT.CREATE')
event_list_validation_result = validateList(events)
self.assertEqual(
event_list_validation_result[0],
PASS,
"event list validation failed due to %s" %
event_list_validation_result[2])
self.debug("Events list contains event SNAPSHOT.CREATE")
volumeFromSnap = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
data_vol_snap.id))
new_vm = VirtualMachine.create(
self.userapiclient,
self.testdata["small"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
zoneid=self.zone.id,
mode=self.zone.networktype
)
new_vm.attach_volume(
self.apiclient,
volumeFromSnap
)
new_vm.reboot(self.apiclient)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=ckecksum_data_disk,
disk_type="datadiskdevice_1",
virt_machine=new_vm
)
# Step 12
data_volume_2 = Volume.create(
self.apiclient,
self.testdata["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.vm_1.start(self.apiclient)
self.vm_1.attach_volume(
self.userapiclient,
data_volume_2
)
self.vm_1.reboot(self.apiclient)
self.vm_1.stop(self.apiclient)
data_vol_snap_1 = Snapshot.create(
self.apiclient,
data_volume_2.id)
self.assertEqual(
data_vol_snap_1.state,
"BackedUp",
"Check if the snapshot state is correct "
)
data_disk_2_list = Volume.list(
self.userapiclient,
listall=self.testdata["listall"],
id=data_volume_2.id
)
self.vm_1.start(self.apiclient)
checksum_data_2 = createChecksum(
service=self.testdata,
virtual_machine=self.vm_1,
disk=data_disk_2_list[0],
disk_type="datadiskdevice_2")
# Step 13
self.vm_1.detach_volume(self.apiclient,
data_volume_2)
self.vm_1.reboot(self.apiclient)
prev_state = data_volume_2.state
data_vol_snap_2 = Snapshot.create(
self.apiclient,
data_volume_2.id)
self.assertEqual(
data_vol_snap_2.state,
prev_state,
"Check if the volume state is correct "
)
data_snapshot_list_2 = list_snapshots(
self.apiclient,
id=data_vol_snap_2.id
)
self.assertNotEqual(
data_snapshot_list_2,
None,
"Check if result exists in list item call"
)
self.assertEqual(
data_snapshot_list_2[0].id,
data_vol_snap_2.id,
"Check resource id in list resources call"
)
volumeFromSnap_2 = Volume.create_from_snapshot(
self.apiclient,
data_vol_snap_2.id,
self.testdata["volume"],
account=self.account.name,
domainid=self.account.domainid,
zoneid=self.zone.id
)
self.vm_2.attach_volume(
self.userapiclient,
volumeFromSnap_2
)
self.vm_2.reboot(self.apiclient)
data_disk_2_list = Volume.list(
self.userapiclient,
listall=self.testdata["listall"],
id=volumeFromSnap_2.id
)
compareChecksum(
self.apiclient,
service=self.testdata,
original_checksum=checksum_data_2,
disk_type="datadiskdevice_2",
virt_machine=self.vm_2
)
# Step 14
self.vm_1.stop(self.apiclient)
with self.assertRaises(Exception):
root_vol_snap.revertVolToSnapshot(self.apiclient)
# Step 15
root_snap = Snapshot.create(
self.apiclient,
root_volume_cluster.id)
with self.assertRaises(Exception):
root_snap.revertVolToSnapshot(self.apiclient)
return
def test_04_delete_snapshot(self):
"""Test Delete Snapshot
"""
# 1. Snapshot the Volume
# 2. Delete the snapshot
# 3. Verify snapshot is removed by calling List Snapshots API
# 4. Verify snapshot was removed from image store
self.debug("Creating volume under account: %s" % self.account.name)
volume = Volume.create(
self.apiclient,
self.services["volume"],
zoneid=self.zone.id,
account=self.account.name,
domainid=self.account.domainid,
diskofferingid=self.disk_offering.id
)
self.debug("Created volume: %s" % volume.id)
self.debug("Attaching volume to vm: %s" % self.virtual_machine.id)
self.virtual_machine.attach_volume(
self.apiclient,
volume
)
self.debug("Volume attached to vm")
volumes = list_volumes(
self.apiclient,
virtualmachineid=self.virtual_machine.id,
type='DATADISK',
id=volume.id
)
self.assertEqual(
isinstance(volumes, list),
True,
"Check list response returns a valid list"
)
snapshot = Snapshot.create(
self.apiclient,
volumes[0].id,
account=self.account.name,
domainid=self.account.domainid
)
snapshot.delete(self.apiclient)
snapshots = list_snapshots(
self.apiclient,
id=snapshot.id
)
self.assertEqual(
snapshots,
None,
"Check if result exists in list item call"
)
self.assertFalse(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot.id))
return
def test_01_createVM_snapshotTemplate(self):
"""Test create VM, Snapshot and Template
"""
# Validate the following
# 1. Deploy VM using default template, small service offering
# and small data disk offering.
# 2. Perform snapshot on the root disk of this VM.
# 3. Create a template from snapshot.
# 4. Create a instance from above created template.
# 5. listSnapshots should list the snapshot that was created.
# 6. verify that secondary storage NFS share contains the reqd
# volume under /secondary/snapshots/$accountid/
# $volumeid/$snapshot_uuid
# 7. verify backup_snap_id was non null in the `snapshots` table
# 8. listTemplates() should return the newly created Template,
# and check for template state as READY"
# 9. listVirtualMachines() command should return the deployed VM.
# State of this VM should be Running.
# Create Virtual Machine
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name,
DomainName=self.account.domain)
self.virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Created VM with ID: %s" % self.virtual_machine.id)
# Get the Root disk of VM
volumes = list_volumes(
userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True
)
volume = volumes[0]
# Create a snapshot from the ROOTDISK
snapshot = Snapshot.create(userapiclient, volume.id)
self.debug("Snapshot created: ID - %s" % snapshot.id)
self.cleanup.append(snapshot)
snapshots = list_snapshots(
userapiclient,
id=snapshot.id
)
self.assertEqual(
isinstance(snapshots, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
snapshots,
None,
"Check if result exists in list snapshots call"
)
self.assertEqual(
snapshots[0].id,
snapshot.id,
"Check snapshot id in list resources call"
)
self.debug(
"select backup_snap_id, account_id, volume_id from snapshots where uuid = '%s';" %
snapshot.id)
snapshot_uuid = snapshot.id
# Generate template from the snapshot
template = Template.create_from_snapshot(
userapiclient,
snapshot,
self.services["templates"]
)
self.debug("Created template from snapshot: %s" % template.id)
self.cleanup.append(template)
templates = list_templates(
userapiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id
)
self.assertNotEqual(
templates,
None,
"Check if result exists in list item call"
)
self.assertEqual(
templates[0].isready,
True,
"Check new template state in list templates call"
)
# Deploy new virtual machine using template
new_virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.debug("Created VM with ID: %s from template: %s" % (
new_virtual_machine.id,
template.id
))
self.cleanup.append(new_virtual_machine)
# Newly deployed VM should be 'Running'
virtual_machines = list_virtual_machines(
userapiclient,
id=new_virtual_machine.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(virtual_machines, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(virtual_machines),
0,
"Check list virtual machines response"
)
for virtual_machine in virtual_machines:
self.assertEqual(
virtual_machine.state,
'Running',
"Check list VM response for Running state"
)
self.assertTrue(
is_snapshot_on_nfs(
self.apiclient,
self.dbclient,
self.config,
self.zone.id,
snapshot_uuid))
return
def test_04_snapshot_limit(self):
"""Test snapshot limit in snapshot policies
"""
# Validate the following
# 1. Perform hourly recurring snapshot on the root disk of VM and keep
# the maxsnapshots as 1
# 2. listSnapshots should list the snapshot that was created
# snapshot folder in secondary storage should contain only one
# snapshot image(/secondary/snapshots/$accountid/$volumeid/)
# Get the Root disk of VM
volumes = list_volumes(self.apiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
self.assertEqual(isinstance(volumes, list), True,
"Check list response returns a valid list")
volume = volumes[0]
# Create a snapshot policy
recurring_snapshot = SnapshotPolicy.create(
self.apiclient, volume.id, self.services["recurring_snapshot"])
self.cleanup.append(recurring_snapshot)
snapshot_policy = list_snapshot_policy(self.apiclient,
id=recurring_snapshot.id,
volumeid=volume.id)
self.assertEqual(isinstance(snapshot_policy, list), True,
"Check list response returns a valid list")
self.assertNotEqual(snapshot_policy, None,
"Check if result exists in list item call")
self.assertEqual(snapshot_policy[0].id, recurring_snapshot.id,
"Check recurring snapshot id in list resources call")
self.assertEqual(snapshot_policy[0].maxsnaps,
self.services["recurring_snapshot"]["maxsnaps"],
"Check interval type in list resources call")
# Sleep for (maxsnaps+1) hours to verify
# only maxsnaps snapshots are retained
time.sleep(
(int(self.services["recurring_snapshot"]["maxsnaps"]) + 1) * 3600)
# Verify the snapshot was created or not
snapshots = list_snapshots(
self.apiclient,
volumeid=volume.id,
intervaltype=\
self.services["recurring_snapshot"]["intervaltype"],
snapshottype='RECURRING',
listall=True
)
self.assertEqual(isinstance(snapshots, list), True,
"Check list response returns a valid list")
self.assertEqual(
len(snapshots), self.services["recurring_snapshot"]["maxsnaps"],
"Check maximum number of recurring snapshots retained")
snapshot = snapshots[0]
# Sleep to ensure that snapshot is reflected in sec storage
time.sleep(self.services["sleep"])
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot.id))
return
def test_01_createVM_snapshotTemplate(self):
"""Test create VM, Snapshot and Template
"""
# Validate the following
# 1. Deploy VM using default template, small service offering
# and small data disk offering.
# 2. Perform snapshot on the root disk of this VM.
# 3. Create a template from snapshot.
# 4. Create a instance from above created template.
# 5. listSnapshots should list the snapshot that was created.
# 6. verify that secondary storage NFS share contains the reqd
# volume under /secondary/snapshots/$accountid/
# $volumeid/$snapshot_uuid
# 7. verify backup_snap_id was non null in the `snapshots` table
# 8. listTemplates() should return the newly created Template,
# and check for template state as READY"
# 9. listVirtualMachines() command should return the deployed VM.
# State of this VM should be Running.
# Create Virtual Machine
userapiclient = self.testClient.getUserApiClient(
UserName=self.account.name, DomainName=self.account.domain)
self.virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=self.template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.debug("Created VM with ID: %s" % self.virtual_machine.id)
# Get the Root disk of VM
volumes = list_volumes(userapiclient,
virtualmachineid=self.virtual_machine.id,
type='ROOT',
listall=True)
volume = volumes[0]
# Create a snapshot from the ROOTDISK
snapshot = Snapshot.create(userapiclient, volume.id)
self.debug("Snapshot created: ID - %s" % snapshot.id)
self.cleanup.append(snapshot)
snapshots = list_snapshots(userapiclient, id=snapshot.id)
self.assertEqual(isinstance(snapshots, list), True,
"Check list response returns a valid list")
self.assertNotEqual(snapshots, None,
"Check if result exists in list snapshots call")
self.assertEqual(snapshots[0].id, snapshot.id,
"Check snapshot id in list resources call")
self.debug(
"select backup_snap_id, account_id, volume_id from snapshots where uuid = '%s';"
% snapshot.id)
snapshot_uuid = snapshot.id
# Generate template from the snapshot
template = Template.create_from_snapshot(userapiclient, snapshot,
self.services["templates"])
self.debug("Created template from snapshot: %s" % template.id)
self.cleanup.append(template)
templates = list_templates(
userapiclient,
templatefilter=self.services["templates"]["templatefilter"],
id=template.id)
self.assertNotEqual(templates, None,
"Check if result exists in list item call")
self.assertEqual(templates[0].isready, True,
"Check new template state in list templates call")
# Deploy new virtual machine using template
new_virtual_machine = VirtualMachine.create(
userapiclient,
self.services["server"],
templateid=template.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id)
self.debug("Created VM with ID: %s from template: %s" %
(new_virtual_machine.id, template.id))
self.cleanup.append(new_virtual_machine)
# Newly deployed VM should be 'Running'
virtual_machines = list_virtual_machines(
userapiclient,
id=new_virtual_machine.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(virtual_machines, list), True,
"Check list response returns a valid list")
self.assertNotEqual(len(virtual_machines), 0,
"Check list virtual machines response")
for virtual_machine in virtual_machines:
self.assertEqual(virtual_machine.state, 'Running',
"Check list VM response for Running state")
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, snapshot_uuid))
return
def test_01_snapshot_on_rootVolume(self):
"""Test create VM with default cent os template and create snapshot
on root disk of the vm
"""
# Validate the following
# 1. Deploy a Linux VM using default CentOS template, use small service
# offering, disk offering
# 2. Create snapshot on the root disk of this newly cteated vm
# 3. listSnapshots should list the snapshot that was created.
# 4. verify that secondary storage NFS share contains the reqd
# volume under /secondary/snapshots/$accountid/$volumeid/$snapshot_uuid
# 5. verify backup_snap_id was non null in the `snapshots` table
# Create virtual machine with small systerm offering and disk offering
new_virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
diskofferingid=self.disk_offering.id,
)
self.debug("Virtual machine got created with id: %s" %
new_virtual_machine.id)
list_virtual_machine_response = VirtualMachine.list(
self.apiclient, id=new_virtual_machine.id)
self.assertEqual(isinstance(list_virtual_machine_response, list), True,
"Check listVirtualMachines returns a valid list")
self.assertNotEqual(len(list_virtual_machine_response), 0,
"Check listVirtualMachines response")
self.cleanup.append(new_virtual_machine)
# Getting root volume id of the vm created above
list_volume_response = Volume.list(
self.apiclient,
virtualmachineid=list_virtual_machine_response[0].id,
type="ROOT",
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_volume_response, list), True,
"Check listVolumes returns a valid list")
self.assertNotEqual(len(list_volume_response), 0,
"Check listVolumes response")
self.debug(
"Snapshot will be created on the volume with voluem id: %s" %
list_volume_response[0].id)
# Perform snapshot on the root volume
root_volume_snapshot = Snapshot.create(
self.apiclient, volume_id=list_volume_response[0].id)
self.debug(
"Created snapshot: %s for vm: %s" %
(root_volume_snapshot.id, list_virtual_machine_response[0].id))
list_snapshot_response = Snapshot.list(self.apiclient,
id=root_volume_snapshot.id,
account=self.account.name,
domainid=self.account.domainid)
self.assertEqual(isinstance(list_snapshot_response, list), True,
"Check listSnapshots returns a valid list")
self.assertNotEqual(len(list_snapshot_response), 0,
"Check listSnapshots response")
# Verify Snapshot state
self.assertEqual(
list_snapshot_response[0].state
in ['BackedUp', 'CreatedOnPrimary'], True,
"Snapshot state is not as expected. It is %s" %
list_snapshot_response[0].state)
self.assertEqual(
list_snapshot_response[0].volumeid, list_volume_response[0].id,
"Snapshot volume id is not matching with the vm's volume id")
self.cleanup.append(root_volume_snapshot)
# Below code is to verify snapshots in the backend and in db.
# Verify backup_snap_id field in the snapshots table for the snapshot created, it should not be null
self.debug(
"select id, removed, backup_snap_id from snapshots where uuid = '%s';"
% root_volume_snapshot.id)
qryresult = self.dbclient.execute(
"select id, removed, backup_snap_id from snapshots where uuid = '%s';"
% root_volume_snapshot.id)
self.assertNotEqual(len(qryresult), 0,
"Check sql query to return snapshots list")
snapshot_qry_response = qryresult[0]
snapshot_id = snapshot_qry_response[0]
is_removed = snapshot_qry_response[1]
backup_snap_id = snapshot_qry_response[2]
self.assertNotEqual(
is_removed, "NULL",
"Snapshot is removed from CS, please check the logs")
msg = "Backup snapshot id is set to null for the backedup snapshot :%s" % snapshot_id
self.assertNotEqual(backup_snap_id, "NULL", msg)
# Check if the snapshot is present on the secondary storage
self.assertTrue(
is_snapshot_on_nfs(self.apiclient, self.dbclient, self.config,
self.zone.id, root_volume_snapshot.id))
return
