def pds_rollback_unassign_vol():
#objects initialization & Authentication
log = PvltLogger(inspect.stack()[0][3],'INFO')
logger = log.logger
host = HostOps(HOST[0])
fio = FioUtils()
pvlLibHandle = pvlclient.New("2.0",CHASSIS_IP,logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER,password=CHASSIS_PASS)
#calling base function to populate the objects
media_group,vol = base_function(pvlLibHandle,logger)
#Creating a snapshot
logger.info("Creating a snapshot : %s"%SNAP_PREFIX)
snapshot = SnapShotOps(SNAP_PREFIX,volobj=vol,create=True)
assert(snapshot != None)
# Restore the vol using its snapshot
status = vol.vol_rollback(snapshot,backup="true")
assert(status == True)
# delete forensic snapshot
status = snapshot.delete_all_forensic_snap()
assert(status == True)
logger.info("1 Vol restore for unassigned volume: PASS")
def pds_vol_rollback_sanity():
host = HostOps(HOST[0])
fio = FioUtils()
# give function name as log file name
log = PvltLogger("Volume_restore", 'INFO')
logger = log.logger
name = MEDIA_GROUP_NAME
pvlLibHandle = pvlclient.New("2.0", CHASSIS_IP, logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER, password=CHASSIS_PASS)
## velidation for prerequisits
drv_cnt = get_active_drive_count(ZONE, pvlLibHandle)
logger.info(ZONE)
logger.info(drv_cnt)
'''
if drv_cnt < 9 :
logger.error('Not sufficient drives active drive count=%s'%drv_cnt)
sys.exit()
if VOL_CNT > 1 :
logger.error('Update the configuration As this test is currently written for 1 vol only')
sys.exit()
'''
md_type = MEDIA_GROUP_TYPE
## creating mediaGroup
logger.info("Creating a MediaGroup")
media_group = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=True)
assert (media_group != None)
## creaing volumes
logger.info("Creating voluems")
volname = VOL_PREFIX
vol = VolumeOps(md=media_group,
name=volname,
size=VOL_SIZE,
vol_res=VOL_RES,
flavor=FLAVOR,
create=True)
assert (vol != None)
time.sleep(10)
#Creating a snapshot
snap_name = "s1"
logger.info("Creating a snapshot : %s" % snap_name)
snapshot = SnapShotOps(snap_name, volobj=vol, create=True)
assert (snapshot != None)
time.sleep(10)
print vol.vol_id
print snapshot.snap_id
################################ 1 Vol restore for unassigned volume
# Restore the vol using its snapshot
status = vol.vol_rollback(snapshot, backup="true")
assert (status == True)
time.sleep(30)
print("1 Vol restore for unassigned volume: PASS")
# delete forensic snaphsot
#status = snapshot.delete_ferensic_snap(ZONE,media_group.name,snapshot.name)
status = snapshot.delete_all_forensic_snap()
#assert(status == 0)
'''
def pds_rollback_unassign_vol():
################################ 1 Vol restore for unassigned volume
#objects initialization & Authentication
log = PvltLogger(inspect.stack()[0][3], 'INFO')
logger = log.logger
host = HostOps(HOST[0])
fio = FioUtils()
pvlLibHandle = pvlclient.New("2.0", CHASSIS_IP, logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER, password=CHASSIS_PASS)
# defining variables
name = MEDIA_GROUP_NAME
md_type = MEDIA_GROUP_TYP
volname = VOL_PREFIX
# validation for prerequisits
drv_cnt = get_active_drive_count(ZONE, pvlLibHandle)
logger.info(ZONE)
logger.info(drv_cnt)
if drv_cnt < 9:
logger.error('Not sufficient drives active drive count=%s' % drv_cnt)
sys.exit()
if VOL_CNT > 1:
logger.error(
'Update the configuration As this test is currently written for 1 vol only'
)
sys.exit()
# creating mediaGroup
logger.info("Creating a MediaGroup")
media_group = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=True)
assert (media_group != None)
# creaing volumes
logger.info("Creating voluems")
vol = VolumeOps(md=media_group,
name=volname,
size=VOL_SIZE,
vol_res=VOL_RES,
flavor=FLAVOR,
create=True)
assert (vol != None)
time.sleep(10)
#Creating a snapshot
snap_name = "s1"
logger.info("Creating a snapshot : %s" % snap_name)
snapshot = SnapShotOps(snap_name, volobj=vol, create=True)
assert (snapshot != None)
time.sleep(10)
# Restore the vol using its snapshot
status = vol.vol_rollback(snapshot, backup="true")
assert (status == True)
time.sleep(60)
# delete forensic snapshot
status = snapshot.delete_all_forensic_snap()
assert (status == True)
print("1 Vol restore for unassigned volume: PASS")
def pds_rollback_with_clone():
#objects initialization & Authentication
log = PvltLogger(inspect.stack()[0][3],'INFO')
logger = log.logger
host = HostOps(HOST[0])
fio = FioUtils()
pvlLibHandle = pvlclient.New("2.0",CHASSIS_IP,logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER,password=CHASSIS_PASS)
#calling base function to populate the objects
media_group,vol = base_function(pvlLibHandle,logger)
# assigning vol
ports= get_volume_network_map(pvlLibHandle, ZONE)
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
# connect vol
logger.info("connecting vol to the host")
status = host.connect_volume(vol)
assert(status == 0)
# write on the volume
logger.info("Starting overwrite on the vol-seq_write")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([vol], host, kwargs)
assert (status==0)
# Creating a snapshot
logger.info("Creating a snapshot : %s"%SNAP_PREFIX)
snapshot = SnapShotOps(SNAP_PREFIX,volobj=vol,create=True)
assert(snapshot != None)
# create clone
clone_name = str(SNAP_PREFIX)+str("_c1")
logger.info("Creating clone name : %s"%clone_name)
cloneObj = CloneOps(clone_name,snapshot,create=True)
# assign clone
logger.info("Assigning clone %s to contollers"%cloneObj.name)
assign = cloneObj.assign_clone(ports,hostnqn=[])
# connect clone to the host
logger.info("Connecting clone %s to the host"%cloneObj.name)
status = host.connect_volume(cloneObj)
assert(status==0)
# start IO on the clone
logger.info("Staring write IO to the clone %s"%clone_name)
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([cloneObj], host, kwargs)
assert (status==0)
# overwrite on the volume
logger.info("Starting overwrite on the vol-seq_write")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xffff","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([vol], host, kwargs)
assert (status==0)
# disconenct the vol
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
# unassign the vol
status = vol.unassign_volume()
assert(status == True)
# restore the volumes using s2
status = vol.vol_rollback(snapshot,backup="true")
assert(status == True)
# connect the vol & verify the data
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
logger.info("connecting the vol")
status = host.connect_volume(vol)
assert(status == 0)
logger.info("Reading from the raw device")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_read([vol], host, kwargs)
assert (status==0)
# delete forensic snapshot
status = snapshot.delete_all_forensic_snap()
assert(status == True)
# disconnect the vol to run teardown
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
# disconnet the clone
logger.info("disconnecting clone : %s"%cloneObj.name)
status = host.disconnect_volume(cloneObj)
time.sleep(10)
def pds_rollback_with_rebuild_20():
#objects initialization & Authentication
log = PvltLogger(inspect.stack()[0][3],'INFO')
logger = log.logger
host = HostOps(HOST[0])
fio = FioUtils()
pvlLibHandle = pvlclient.New("2.0",CHASSIS_IP,logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER,password=CHASSIS_PASS)
#calling base function to populate the objects
media_group,vol = base_function(pvlLibHandle,logger)
# assign the vol
ports= get_volume_network_map(pvlLibHandle, ZONE)
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
# connet to the host
status = host.connect_volume(vol)
assert(status == 0)
# powring off two drives
mediaList = media_group.get_media_group_disk()
media = [mediaList[0]] + [mediaList[1]]
logger.info("Powering OFF drive : %s"%media)
status = power_off_drive([media_group.md_disk[1],media_group.md_disk[0]],pvlLibHandle)
# write on the voluem
logger.info("Starting overwrite on the vol-seq_write")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([vol], host, kwargs)
assert (status==0)
#Taking snaphost
logger.info("Taking snapshot :%s"%SNAP_PREFIX)
snapshot = SnapShotOps(SNAP_PREFIX,volobj=vol,create=True)
assert(snapshot != None)
# poweron the drives
logger.info("Powering ON drive : %s"%media)
status = power_on_drive(media,pvlLibHandle)
time.sleep(60)
# start rebuild
logger.info("Start rebuild 2>0")
status=media_group.synchronous_rebuild_media_group()
# overwrite on the volume
logger.info("Starting overwrite on the vol-seq_write")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xffff","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([vol], host, kwargs)
assert (status==0)
# disconenct the vol
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
# unassign the vol
status = vol.unassign_volume()
assert(status == True)
# restore the volumes using s2
status = vol.vol_rollback(snapshot,backup="true")
assert(status == True)
# connect the vol & verify the data
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
logger.info("connecting the vol")
status = host.connect_volume(vol)
assert(status==0)
logger.info("Reading from the raw device")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_read([vol], host, kwargs)
assert (status==0)
# delete forensic snapshot
status = snapshot.delete_all_forensic_snap()
assert(status == True)
# disconnect the vol to run teardown
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
def pds_rollback_with_IO():
#objects initialization & Authentication
log = PvltLogger(inspect.stack()[0][3],'INFO')
logger = log.logger
host = HostOps(HOST[0])
fio = FioUtils()
pvlLibHandle = pvlclient.New("2.0",CHASSIS_IP,logger=logger)
result = pvlLibHandle.auth.login(user=CHASSIS_USER,password=CHASSIS_PASS)
#calling base function to populate the objects
media_group,vol = base_function(pvlLibHandle,logger)
# assign the vol
ports= get_volume_network_map(pvlLibHandle, ZONE)
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
# connet to the host
status = host.connect_volume(vol)
assert(status == 0)
#start fio on all the volumes
logger.info("Starting write on the vol-seq_write")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_write([vol], host, kwargs)
assert (status == 0)
#Taking snaphost
logger.info("Taking snapshot :%s"%SNAP_PREFIX)
snapshot = SnapShotOps(SNAP_PREFIX,volobj=vol,create=True)
assert(snapshot != None)
#Write on remaning space of the volumes
logger.info("Starting write on other space of the vol ")
kwargs = {'offset':"45g",'size':'5g',"verify_pattern":"0xffff","verify_interval":4096,"do_verify":1}
status,response=fio.rand_write([vol], host, kwargs)
assert (status == 0)
#disconnect the vol
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
# unassign the vol
status = vol.unassign_volume()
assert(status == True)
#restore using latest snapshot
status = vol.vol_rollback(snapshot,backup="true")
assert(status == True)
#cheking data integrity by rading the volumes data
#assign and then connecting the vol
logger.info("Assigning vols ")
status = vol.assign_volume(ports,hostnqn=[])
assert(status == True)
logger.info("connecting the vol")
status = host.connect_volume(vol)
assert(status == 0)
logger.info("Reading from the raw device")
kwargs = {'offset':"0",'size':'40%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
status,response=fio.seq_read([vol], host, kwargs)
assert (status==0)
#delete forensic snapshot
status = snapshot.delete_all_forensic_snap()
assert(status == True)
# disconnect the vol to run teardown
logger.info("disconnecting the vol from the host")
status = host.disconnect_volume(vol)
time.sleep(10)
