def snapshot_info(self):
# Check snapshot info using snap name
g.log.info("Checking snapshot info using snap name")
snap_info_chk = get_snap_info_by_snapname(self.mnode, self.snap1)
self.assertIsNotNone(snap_info_chk, "Failed to get snap info")
self.assertEqual(snap_info_chk['name'], "%s" % self.snap1,
"Failed to show snapshot info for %s" % self.snap1)
g.log.info("Successfully checked snapshot info for %s", self.snap1)
# Check snapshot info using volname
g.log.info("Checking snapshot info using volname")
snap_vol_info = get_snap_info_by_volname(self.mnode, self.volname)
self.assertIsNotNone(snap_vol_info, "Failed to get snap info")
self.assertEqual(snap_vol_info['originVolume']['name'],
"%s" % self.volname,
"Failed to show snapshot info for %s" % self.volname)
g.log.info("Successfully checked snapshot info for %s", self.volname)
# Validate snapshot information
g.log.info("Validating snapshot information")
info_snaps = get_snap_info(self.mnode)
self.assertIsNotNone(snap_vol_info, "Failed to get snap info")
for snap in range(0, 2):
self.assertEqual(info_snaps[snap]['name'], "snap%s" % snap,
"Failed to validate"
"snap information")
g.log.info("Successfully Validated snap Information")
def snapshot_info(self):
"""
This section checks the snapshot information:
* Using snapname
* Using volname
* Without using snapname or volname
"""
# Check snapshot info using snapname
for snap in self.snapshots:
snap_info_chk = get_snap_info_by_snapname(self.mnode, snap)
self.assertIsNotNone(snap_info_chk, "Failed to get snap info")
self.assertEqual(snap_info_chk['name'], "%s" % snap,
"Failed to show snapshot info for %s" % snap)
g.log.info("Successfully validated snapshot info for %s", snap)
# Check snapshot info using volname
snap_vol_info = get_snap_info_by_volname(self.mnode, self.volname)
self.assertIsNotNone(snap_vol_info, "Failed to get snap info")
self.assertEqual(snap_vol_info['originVolume']['name'],
"%s" % self.volname,
"Failed to show snapshot info for %s" % self.volname)
g.log.info("Successfully validated snapshot info for %s", self.volname)
# Validate snapshot information without using snapname or volname
info_snaps = get_snap_info(self.mnode)
self.assertIsNotNone(info_snaps, "Failed to get snap info")
counter = 0
for snap in self.snapshots:
self.assertEqual(info_snaps[counter]['name'], snap,
"Failed to validate snap information")
counter += 1
g.log.info("Successfully validated snapshot information")
def test_snap_info(self):
"""
1. Create volumes
2. create multiple snapshots
3. Check snapshot info for snapshots created
using snap name, using volume name and
without using snap name and volume name
"""
# pylint: disable=too-many-statements
# Creating snapshot with description
g.log.info("Starting to Create snapshot")
for count in range(0, 2):
self.snap = "snap%s" % count
ret, _, _ = snap_create(self.mnode, self.volname,
self.snap,
description='$p3C!@l C#@R@cT#R$')
self.assertEqual(ret, 0, ("Failed to create snapshot for volume %s"
% self.volname))
g.log.info("Snapshot %s created successfully"
" for volume %s", self.snap, self.volname)
# Check snapshot info using snap name
g.log.info("Checking snapshot info using snap name")
snap_info_chk = get_snap_info_by_snapname(self.mnode,
self.snap1)
self.assertIsNotNone(snap_info_chk, "Failed to get snap info")
self.assertEqual(snap_info_chk['name'], "%s" % self.snap1, "Failed "
"to show snapshot info for %s"
% self.snap1)
g.log.info("Successfully checked snapshot info for %s", self.snap1)
# Check snapshot info using volname
g.log.info("Checking snapshot info using volname")
snap_vol_info = get_snap_info_by_volname(self.mnode, self.volname)
self.assertIsNotNone(snap_vol_info, "Failed to get snap info")
self.assertEqual(snap_vol_info['originVolume']['name'], "%s"
% self.volname,
"Failed to show snapshot info for %s"
% self.volname)
g.log.info("Successfully checked snapshot info for %s", self.volname)
# Validate snapshot information
g.log.info("Validating snapshot information")
info_snaps = get_snap_info(self.mnode)
self.assertIsNotNone(info_snaps, "Failed to get snap info")
for snap in range(0, 2):
self.assertEqual(info_snaps[snap]['name'], "snap%s" % snap,
"Failed to validate"
"snap information")
g.log.info("Successfully Validated snap Information")
def test_activate_deactivate(self):
# pylint: disable=too-many-branches, too-many-statements
"""
Verifying Snapshot activation/deactivation functionality.
* Create Snapshot
* Validate snapshot info before activation
* Validate snapshot status before activation
* Activate snapshot
* Validate snapshot info after activation
* Validate snapshot status after activation
* Deactivate snapshot
* Validate snapshot info after deactivation
* Validate snapshot status after deactivation
"""
# Create Snapshot
snap_name = 'snap_%s' % self.volname
g.log.info("Starting to Create Snapshot %s", snap_name)
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0,
("Snapshot Creation failed for %s", snap_name))
g.log.info("Successfully created Snapshot %s for volume %s", snap_name,
self.volname)
# Validate Snapshot Info Before Activation
g.log.info("Validating 'snapshot info' in 'stopped' state before "
"activating the snapshot")
ret = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertIsNotNone(
ret, ("Failed to Fetch Snapshot info for %s", snap_name))
g.log.info("Snapshot info Success for %s", ret['snapVolume']['status'])
self.assertEqual(
ret['snapVolume']['status'], 'Stopped',
("Unexpected: Snapshot %s Status is in Started state", snap_name))
g.log.info("Expected: Snapshot is in Stopped state as it is "
"not Activated")
# Validate Snapshot Status Before Activation
g.log.info("Validating 'snapshot status' in 'stopped' state before "
"activating the snapshot")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
self.assertIsNotNone(
ret, ("Failed to Fetch Snapshot status for %s", snap_name))
g.log.info("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
self.assertEqual(brick['pid'], 'N/A',
("Unexpected: Brick Pid '%s' is available for %s",
brick['pid'], brick['path']))
g.log.info("Expected: Deactivated Snapshot Brick PID is 'N/A'")
# Activate Snapshot
g.log.info("Starting to Activate %s", snap_name)
ret, _, _ = snap_activate(self.mnode, snap_name)
self.assertEqual(ret, 0,
("Snapshot Activation Failed for %s", snap_name))
g.log.info("Snapshot %s Activated Successfully", snap_name)
# Validate Snapshot Info After Activation
g.log.info("Validating 'snapshot info' in 'started' state after"
" activating the snapshot")
snap_info = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertEqual(snap_info['snapVolume']['status'], "Started",
("Failed to Fetch Snapshot info after activate "
"for %s", snap_name))
g.log.info("Success: Snapshot info in 'started' state")
# Validate Snaphot Status After Activation
g.log.info("Validating 'snapshot status' in started state after "
"activating the snapshot")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
for brick in ret['volume']['brick']:
self.assertNotEqual(brick['pid'], 'N/A',
("Brick Path %s Not Available for Activated "
"Snapshot %s", (brick['path'], snap_name)))
g.log.info("Sucessfully validated Activated Snapshot Brick Path "
"Available")
# Deactivate Snapshot
g.log.info("Starting to Deactivate %s", snap_name)
ret, _, _ = snap_deactivate(self.mnode, snap_name)
self.assertEqual(ret, 0,
("Snapshot Deactivation Failed for %s", snap_name))
g.log.info("Successfully Deactivated Snapshot %s", snap_name)
# Validate Snapshot Info After Deactivation
g.log.info("Validating 'snapshot info' in stopped state after "
"deactivating the snapshot")
ret = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertEqual(ret['snapVolume']['status'], 'Stopped',
("Snapshot Status is not in 'Stopped' State"))
g.log.info("Expected: Snapshot is in Stopped state after Deactivation")
# Validate Snaphot Status After Deactivation
g.log.info("Validating 'snapshot status' in started state after "
"deactivating the snapshot")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
for brick in ret['volume']['brick']:
self.assertEqual(brick['pid'], 'N/A',
("Deactivated Snapshot Brick Pid %s available "
"for %s", brick['pid'], brick['path']))
g.log.info("Expected: Deactivated Snapshot Brick PID is 'N/A'")
def test_snap_glusterd_down(self):
# pylint: disable=too-many-statements
"""
Steps:
1. create a volume
2. mount volume
3. create snapshot of that volume
4. validate using snapshot info
5. Activate snapshot
6. List all snapshots present
7. validate using snapshot info
8. Stop glusterd on one node
9. Check glusterd status
10. deactivate created snapshot
11. Start glusterd on that node
12. Check glusterd status
13. validate using snapshot info
13. Check all peers are connected
"""
# Creating snapshot:
g.log.info("Starting to Create snapshot")
ret, _, _ = snap_create(self.mnode, self.volname, self.snap)
self.assertEqual(ret, 0, ("Failed to create snapshot %s for volume %s"
% (self.snap, self.volname)))
g.log.info("Snapshot %s created successfully "
"for volume %s", self.snap, self.volname)
# Check snapshot info
g.log.info("Checking snapshot info")
snap_info = get_snap_info_by_snapname(self.mnode, self.snap)
self.assertIsNotNone(snap_info, "Failed to get snap information"
"for snapshot %s" % self.snap)
status = snap_info['snapVolume']['status']
self.assertNotEqual(status, 'Started', "snapshot %s "
"not started" % self.snap)
g.log.info("Successfully checked snapshot info")
# Activating snapshot
g.log.info("Starting to Activate Snapshot")
ret, _, _ = snap_activate(self.mnode, self.snap)
self.assertEqual(ret, 0, ("Failed to Activate snapshot %s"
% self.snap))
g.log.info("Snapshot %s activated successfully", self.snap)
# snapshot list
g.log.info("Starting to validate list of snapshots")
snap_list1 = get_snap_list(self.mnode)
self.assertIsNotNone(snap_list1, "Failed to list all the snapshot")
self.assertEqual(len(snap_list1), 1, "Failed to validate snap list")
g.log.info("Snapshot list successfully validated")
# Check snapshot info
g.log.info("Checking snapshot info")
snap_info = get_snap_info_by_snapname(self.mnode, self.snap)
status = snap_info['snapVolume']['status']
self.assertEqual(status, 'Started', "Failed to"
"start snapshot info")
g.log.info("Successfully checked snapshot info")
# Stop Glusterd on one node
g.log.info("Stopping Glusterd on one node")
ret = stop_glusterd(self.servers[1])
# Check Glusterd status
g.log.info("Check glusterd running or not")
count = 0
while count < 80:
ret = is_glusterd_running(self.servers[1])
if ret == 1:
break
time.sleep(2)
count += 2
self.assertEqual(ret, 1, "Unexpected: glusterd running on node %s" %
self.servers[1])
g.log.info("Expected: Glusterd not running on node %s",
self.servers[1])
# de-activating snapshot
g.log.info("Starting to de-activate Snapshot")
ret, _, _ = snap_deactivate(self.mnode, self.snap)
self.assertEqual(ret, 0, ("Failed to deactivate snapshot %s"
% self.snap))
g.log.info("Snapshot %s deactivated successfully", self.snap)
# validate snapshot info
g.log.info("Checking snapshot info")
snap_info = get_snap_info_by_snapname(self.mnode, self.snap)
status = snap_info['snapVolume']['status']
self.assertNotEqual(status, 'Started', "snapshot %s "
"not started" % self.snap)
g.log.info("Successfully validated snapshot info")
# Start Glusterd on node
g.log.info("Starting Glusterd on node %s", self.servers[1])
ret = start_glusterd(self.servers[1])
self.assertTrue(ret, "Failed to start glusterd on %s node"
% self.servers[1])
g.log.info("Successfully started glusterd on "
"%s node", self.servers[1])
# Check Glusterd status
g.log.info("Check glusterd running or not")
count = 0
while count < 80:
ret = is_glusterd_running(self.servers[1])
if ret:
break
time.sleep(2)
count += 2
self.assertEqual(ret, 0, "glusterd not running on node %s "
% self.servers[1])
g.log.info("glusterd is running on %s node",
self.servers[1])
# validate snapshot info
g.log.info("Checking snapshot info")
snap_info = get_snap_info_by_snapname(self.mnode, self.snap)
self.assertIsNotNone(snap_info, "Failed to get snap info for"
" snapshot %s" % self.snap)
status = snap_info['snapVolume']['status']
self.assertNotEqual(status, 'Started', "snapshot"
" %s failed to validate with snap info"
% self.snap)
g.log.info("Successfully validated snapshot info")
# Check all the peers are in connected state
g.log.info("Validating all the peers are in connected state")
for servers in self.servers:
count = 0
while count < 80:
ret = is_peer_connected(self.mnode, servers)
if ret:
break
time.sleep(2)
count += 2
self.assertTrue(ret, "All the nodes are not in cluster")
g.log.info("Successfully validated all the peers")
def test_activate_deactivate(self):
# pylint: disable=too-many-branches, too-many-statements
"""
Verifying Snapshot activation/deactivation functionality.
"""
snap_name = 'snap_%s' % self.volname
# Create Snapshot
g.log.info("Starting to Create Snapshot %s", snap_name)
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0, "Snapshot Creation failed"
" for %s" % snap_name)
g.log.info("Snapshot %s of volume %s created"
" successfully", snap_name, self.volname)
# Validate Snapshot Info Before Activation
ret = get_snap_info_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"info for %s" % snap_name)
g.log.info("Snapshot info Success"
"for %s", ret['snapVolume']['status'])
if ret['snapVolume']['status'] != 'Stopped':
raise ExecutionError("Unexpected: "
"Snapshot %s Status is in "
"Started State" % snap_name)
g.log.info("Expected: Snapshot is in Stopped state "
"as it is not Activated")
# Validate Snapshot Status Before Activation
ret = get_snap_status_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"status for %s" % snap_name)
g.log.info("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
if brick['pid'] != 'N/A':
raise ExecutionError(
"Brick Pid %s available for %s" % brick['pid'],
brick['path'])
g.log.info("Deactivated Snapshot Brick PID N/A as Expected")
# Activate Snapshot
g.log.info("Starting to Activate %s", snap_name)
ret, _, _ = snap_activate(self.mnode, snap_name)
self.assertEqual(ret, 0, "Snapshot Activation Failed"
" for %s" % snap_name)
g.log.info("Snapshot %s Activated Successfully", snap_name)
# Validate Snapshot Info After Activation
g.log.info("Validate snapshot info")
snap_info = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertEqual(
snap_info['snapVolume']['status'], "Started",
"Failed to Fetch Snapshot"
"info after activate "
"for %s" % snap_name)
g.log.info("Snapshot info Success ")
# Validate Snaphot Status After Activation
g.log.info("Validate snapshot status")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
for brick in ret['volume']['brick']:
self.assertNotEqual(
brick['pid'], 'N/A', "Brick Path "
"%s Not Available "
"for Activated Snapshot %s" % (brick['path'], snap_name))
g.log.info("Activated Snapshot Brick Path " "Available as Expected")
# Validation After Snapshot Deactivate
g.log.info("Starting to Deactivate %s", snap_name)
ret, _, _ = snap_deactivate(self.mnode, snap_name)
self.assertEqual(ret, 0, "Snapshot Deactivation Failed"
" for %s" % snap_name)
g.log.info("Snapshot %s Deactivation Successfully", snap_name)
# Validate Snapshot Info After Deactivation
ret = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertEqual(ret['snapVolume']['status'], 'Stopped',
"Snapshot Status is not "
"in Stopped State")
g.log.info("Snapshot is in Stopped state after Deactivation")
# Validate Snaphot Status After Activation
g.log.info("Validate snapshot status")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
for brick in ret['volume']['brick']:
self.assertEqual(
brick['pid'], 'N/A', "Deactivated "
"Snapshot Brick "
"Pid %s available "
"for %s" % (brick['pid'], brick['path']))
g.log.info("Deactivated Snapshot Brick PID N/A as Expected")
def test_activate_on_create(self):
# pylint: disable=too-many-branches, too-many-statements
"""
Verifying Snapshot activate on create
* Create a default snapshot
* Enable activate-on-create snapshot config option
* Create more snapshots
* Validate snapshot info after snapshot create. It should be in
started state.
* Validate snapshot status after snapshot create. It should be in
started state.
* Validate the default snapshot info and status. It should be in
stopped state
"""
# Create Default Snapshot
g.log.info("Starting to Create Snapshot one")
snap_default = "snap_%s" % self.volname
ret, _, _ = snap_create(self.mnode, self.volname, snap_default)
self.assertEqual(ret, 0, ("Snapshot Creation failed for %s",
snap_default))
g.log.info("Successfully created Snapshot %s of volume %s",
snap_default, self.volname)
# Enable activate_on_create snapshot
g.log.info("Enabling snapshot activate-on-create config option")
ret, _, _ = set_snap_config(self.mnode, self.option_enable)
self.assertEqual(ret, 0, "Failed to execute set_snap_config")
g.log.info("Validating the value of activate-on-create")
ret = get_snap_config(self.mnode, self.volname)
self.assertIsNotNone(ret, ("Failed to execute get_snap_config"))
self.assertIn('enable', (ret['systemConfig']['activateOnCreate']),
("Failed to validate activate-on-create value as "
"'enabled'"))
g.log.info("Successfully enabled activate-on-create")
# Create Snapshots after enabling activate-on-create
g.log.info("Starting to Create Snapshots")
for snap_count in range(1, 5):
snap_name = "snap_%s" % snap_count
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0, ("Snapshot Creation failed for %s",
snap_name))
g.log.info("Successfully created Snapshot %s of volume %s",
snap_name, self.volname)
# Validate Snapshot Info After Snapshot Create
g.log.info("Validating 'snapshot info' after enabling "
"activate-on-create")
ret = get_snap_info_by_snapname(self.mnode, snap_name)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot info after "
"activation for %s", snap_name))
g.log.info("Snapshot info Success for %s",
ret['snapVolume']['status'])
self.assertEqual(ret['snapVolume']['status'], 'Started',
("Activated Snapshot is in Stopped State %s",
(ret['snapVolume']['status'])))
g.log.info("Snapshot %s is Activated By Default - %s state",
snap_name, (ret['snapVolume']['status']))
# Validate Snaphot Status After Snapshot Create
g.log.info("Validating 'snapshot status' after enabling "
"activate-on-create")
ret = get_snap_status_by_snapname(self.mnode, snap_name)
self.assertIsNotNone("Failed to Fetch Snapshot status for %s",
snap_name)
g.log.info("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
self.assertNotEqual(brick['pid'], 'N/A',
("Brick Path %s Not Available for "
"Activated Snapshot %s",
(brick['path'], snap_name)))
g.log.info("Success: Snapshot Brick Path Available")
# Validate Snapshot Info for the 'default' snapshot
# Expected to be Stopped
g.log.info("Validating 'snapshot info' of the 'default' snapshot")
ret = get_snap_info_by_snapname(self.mnode, snap_default)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot info for %s",
snap_default))
g.log.info("Snapshot info Success for %s", ret['snapVolume']['status'])
self.assertEqual(ret['snapVolume']['status'], 'Stopped',
("Snapshot Status is not in Stopped State"))
g.log.info("Snapshot %s is in Stopped state as it "
"is not Activated", snap_default)
# Validate Snapshot Status for the 'default' snapshot
# Expected to be N/A
g.log.info("Validating 'snapshot status' of the 'default' snapshot")
ret = get_snap_status_by_snapname(self.mnode, snap_default)
self.assertIsNotNone(ret, ("Failed to Fetch Snapshot status for %s",
snap_default))
g.log.info("Snapshot Status Success for %s", snap_default)
for brick in ret['volume']['brick']:
self.assertEqual(brick['pid'], 'N/A',
("Brick Pid available for %s", brick['path']))
g.log.info("Success: Snapshot %s Brick PID is 'N/A'", snap_default)
def test_activate_on_create(self):
# pylint: disable=too-many-branches
"""
Verifying Snapshot activate on create
"""
# Create Default Snapshot
g.log.info("Starting to Create Snapshot one")
snap_default = "snap_%s" % self.volname
ret, _, _ = snap_create(self.mnode, self.volname, snap_default)
self.assertEqual(ret, 0, "Snapshot Creation failed"
" for %s" % snap_default)
g.log.info("Snapshot %s of volume %s created"
" successfully", snap_default, self.volname)
# Enable activate_on_create snapshot
ret, _, _ = set_snap_config(self.mnode, self.option_enable)
self.assertEqual(ret, 0, "Failed to execute set_snap_config")
ret = get_snap_config(self.mnode, self.volname)
if ret is None:
raise ExecutionError("Failed to execute get_snap_config")
if 'enable' not in ret['systemConfig']['activateOnCreate']:
raise ExecutionError("Failed to enable activate-on-create")
g.log.info("set_snap_config Success to enable " "activate-on-create")
# Create Snapshot Snapshots
g.log.info("Starting to Create Snapshot two")
for snap_count in range(1, 5):
snap_name = "snap_%s" % snap_count
ret, _, _ = snap_create(self.mnode, self.volname, snap_name)
self.assertEqual(ret, 0, "Snapshot Creation failed"
" for %s" % snap_name)
g.log.info("Snapshot %s of volume %s created"
" successfully", snap_name, self.volname)
# Validate Snapshot Info After Snapshot Create
ret = get_snap_info_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"info after activate "
"for %s" % snap_name)
g.log.info("Snapshot info Success "
"for %s", ret['snapVolume']['status'])
if ret['snapVolume']['status'] != 'Started':
raise ExecutionError("Activated Snapshot is in Stopped "
"State %s" %
(ret['snapVolume']['status']))
g.log.info("%s Activated By "
"Default- %s state", snap_name,
(ret['snapVolume']['status']))
# Validate Snaphot Status After Snapshot Create
ret = get_snap_status_by_snapname(self.mnode, snap_name)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"status for %s" % snap_name)
g.log.error("Snapshot Status Success for %s", snap_name)
for brick in ret['volume']['brick']:
if brick['pid'] == 'N/A':
raise ExecutionError("Brick Path %s Not Available "
"for Activated Snapshot %s" %
(brick['path'], snap_name))
g.log.info("snap_2 Snapshot Brick Path Available as Expected")
# Validate Deactivated Snapshot Info
# Expected to be Stopped
ret = get_snap_info_by_snapname(self.mnode, snap_default)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
" info for %s" % snap_default)
g.log.info("Snapshot info Success for %s", ret['snapVolume']['status'])
if ret['snapVolume']['status'] != 'Stopped':
raise ExecutionError("Snapshot Status is not in Stopped State")
g.log.info("Snapshot %s is in Stopped state as it "
"is not Activated", snap_default)
# Validate Deactivated Snapshot status
# Expected tobe NA
ret = get_snap_status_by_snapname(self.mnode, snap_default)
if ret is None:
raise ExecutionError("Failed to Fetch Snapshot"
"status for %s" % snap_default)
g.log.info("Snapshot Status Success for %s", snap_default)
for brick in ret['volume']['brick']:
if brick['pid'] != 'N/A':
raise ExecutionError("Brick Pid available for %s" %
brick['path'])
g.log.info("Deactivated Snapshot Brick PID N/A as Expected")
