def base_function(pvlLibHandle, logger):
    # defining variables
    name = MEDIA_GROUP_NAME
    md_type = MEDIA_GROUP_TYPE
    # 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)
        assert (drv_cnt > 8)

        # creating mediaGroup
    logger.info("Creating a MediaGroup")
    media_group = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=True)
    assert (media_group != None)

    # creaing volumes
    vol_list = []
    for i in range(VOL_CNT):
        volname = "%s_%s" % (VOL_PREFIX, i)
        logger.info("Creating voluems")
        vol = VolumeOps(md=media_group,
                        name=volname,
                        size=VOL_SIZE,
                        vol_res=VOL_RES,
                        flavor=FLAVOR,
                        create=True)
        vol_list.append(vol)
        assert (vol != None)
    return media_group, vol_list
示例#2
0
def base_function(pvlLibHandle,logger):
        # defining variables
    name = MEDIA_GROUP_NAME
    md_type = MEDIA_GROUP_TYPE
    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)
    return media_group,vol
示例#3
0
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)
    '''
示例#4
0
def pds_vol_restore_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)
    ## creating mediaGroup
    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)
        #assert(drv_cnt > 8 )

    # take it from config
    #md_type = 'RAID-0 (18+0)' if drv_cnt == 18 else 'RAID-6 (7+2)'
    md_type = MEDIA_GROUP_TYPE
    logger.info("Creating a MediaGroup")
    media_group = MediaGroupOps(pvlLibHandle,
                                name,
                                ZONE,
                                md_type,
                                create=False)
    assert (media_group != None)
    ## creaing volumes
    logger.info("Creating voluems")
    vol_list = []
    for i in range(1):
        volname = '%s_%s' % (VOL_PREFIX, i)
        vol = VolumeOps(md=media_group,
                        name=volname,
                        size=VOL_SIZE,
                        vol_res=VOL_RES,
                        flavor=FLAVOR,
                        create=True)
        vol_list.append(vol)
        #Creating a snapshot
    snap_name = "s1"
    logger.info("Creating a snapshot : %s" % snap_name)
    snapshot = SnapShotOps(snap_name, volobj=vol_list[0], create=True)
    assert (snapshot != None)

    ################################ 1 Vol restore for unassigned volume
    # Restore the vol using its snapshot
    status = snapshot.vol_restore()
    #snap_id = snapshot.snap_id
    #print snap_id
    #logger.info("Running vol_restore using following snaphost : %s"%snap_name)
    #status = pvlLibHandle.system.generic_api('POST', '/storage/snapshots/%s/restore'%snap_id)
    #assert(status != 200)
    #time.sleep(60)
    print("1 Vol restore for unassigned volume: PASS")
    '''
示例#5
0
def pds_raid6_io_sanity():
    host = HostOps(HOST[0])
    fio = FioUtils()
        # give function name as log file name
    log = PvltLogger("raid6_io_sanity",'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")
    #vol_list = []
    volname = VOL_PREFIX
    vol=VolumeOps(md=media_group,name=volname,size=VOL_SIZE,vol_res=VOL_RES,flavor=FLAVOR,create=True)
    assert(vol != None )
        # Assigning and connecting the volume
    ports = get_two_port_diff_ctlr(ZONE)
    logger.info("Assigning vols ")
    status  = vol.assign_volume(ports,hostnqn=[])
    assert(status)
    status = host.connect_volume(vol)
    time.sleep(10)
    assert(status == 0)

    #ioitems = ['write','randwrite','readwrite','randrw','read']
    #blk_list = ['4k','8k','16k','32k','64k','128k','256k','512k','1m','2m']
    ioitems = ['write']
    blk_list = ['4k']

################################ 1. FIO on online volume
        #start fio on all the volumes with BS:4k/IODEPTH:128
     for blk_size in blk_list:
         for io_type in ioitems:
             logger.info("Starting IO Online volumes : IO_TYPE=%s :BS=%s"%(io_type,blk_size))
             kwargs = {'offset':"0",'bs':blk_size,'size':'5%',"verify_pattern":"0xABCD","verify_interval":4096,"do_verify":1}
             status,response=fio.generic_fio(io_type,[vol], host, kwargs)
             assert (status == 0)
             logger.info("Completed IO for Online volume with:IO_TYPE=%s||BS=%s"%(io_type,blk_size))
示例#6
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")
示例#7
0
def pds_create_mediagroup():
    global logger
    global pvlLibHandle
    log = PvltLogger("rebuild_operation", '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)

    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)
        #assert(drv_cnt > 8 )

    md_type = 'RAID-0 (18+0)' if drv_cnt == 18 else 'RAID-6 (6+2+1)'

    md = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=False)
    media_group = md
    assert (md != None)
    ## deleting mediaGroup
    #print("now deleting the mg in 5 sec")
    #time.sleep(5)
    #media_group.delete_mediagroup()

    ## creaing volumes
    vol_list = []
    for i in range(2):
        volname = str(VOL_PREFIX) + str("_") + str(i)
        vol = VolumeOps(md=media_group,
                        name=volname,
                        size=VOL_SIZE,
                        vol_res=VOL_RES,
                        flavor=FLAVOR,
                        create=True)
        vol_list.append(vol)
    #print("following volumes have been created : %s"%vol_list)
    #'''
    ## assign volume
    ports = get_two_port_diff_ctlr(ZONE)
    for v in vol_list:
        assign = v.assign_volume(ports)
    #connecting  voluems to the host
    for v in vol_list:
        host = HostOps(HOST[0])
        status = host.connect_volume(v)
        #assert(status==0)
    # stert fio on all the volumes
    '''
示例#8
0
def base_function(pvlLibHandle, logger):
    #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_TYPE
    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)
    return media_group, vol
示例#9
0
def pds_create_mediagroup():
    global logger
    global pvlLibHandle
    log = PvltLogger("rebuild_operation", '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)

    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)
        #assert(drv_cnt > 8 )

    md_type = 'RAID-0 (18+0)' if drv_cnt == 18 else 'RAID-6 (7+2)'

    md = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=False)
    media_group = md
    assert (md != None)
    ## deleting mediaGroup
    #print("now deleting the mg in 5 sec")
    #time.sleep(5)
    #media_group.delete_mediagroup()

    ## creaing volumes
    vol_list = []
    for i in range(4):
        volname = str(VOL_PREFIX) + str("_") + str(i)
        vol = VolumeOps(md=media_group,
                        name=volname,
                        size=VOL_SIZE,
                        vol_res=VOL_RES,
                        flavor=FLAVOR,
                        create=True)
        vol_list.append(vol)
    #print("following volumes have been created : %s"%vol_list)
    #'''
    ## assign volume
    ports = get_two_port_diff_ctlr(ZONE)
    for v in vol_list:
        assign = v.assign_volume(ports)
    #connecting  voluems to the host
    for v in vol_list:
        host = HostOps(HOST[0])
        status = host.connect_volume(v)
        #assert(status==0)
    # stert fio on all the volumes
    #'''
    def startIO():
        p1 = multiprocessing.current_process()
        logger.info("Starting : %s : %s" % (p1.name, p1.pid))
        print "Starting :", p1.name, p1.pid
        host = HostOps(HOST[0])  # getting host object
        fio = FioUtils()  # getting fio object
        kwargs = {
            'size': '100%',
            "verify_pattern": "0xABCD",
            "verify_interval": 4096,
            "do_verify": 1
        }
        status, response = fio.rand_read_write(vol_list, host, kwargs)
        assert (status == 0)

    ### getting used disks in the mediaGroup
    def rebuld_loop(no_of_iterations):
        p2 = multiprocessing.current_process()
        logger.info("Starting : %s : %s" % (p2.name, p2.pid))
        print "Starting", p2.name, p2.pid
        for i in range(no_of_iterations):
            mediaList = media_group.get_media_group_disk()
            media = [mediaList[0], mediaList[1]]
            status = power_off_drive(media, pvlLibHandle)
            time.sleep(30)
            status = power_on_drive(media, pvlLibHandle)
            time.sleep(120)
            status = media_group.rebuild_media_group()
            logger.info(status)
            time.sleep(60)
            #assert (status==0)

    p1 = multiprocessing.Process(name="StartFio", target=startIO)
    p1.deamon = False
    p2 = multiprocessing.Process(name="2_drive_rebuld",
                                 target=rebuld_loop,
                                 args=(10, ))
    p2.deamon = True

    p1.start()
    p2.start()
    p1.join()
    p2.join()
示例#10
0
def pds_vol_restore_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")
    #vol_list = []
    volname = VOL_PREFIX
    vol = VolumeOps(md=media_group,
                    name=volname,
                    size=VOL_SIZE,
                    vol_res=VOL_RES,
                    flavor=FLAVOR,
                    create=True)
    assert (vol != None)

    #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)

    ################################ 1 Vol restore for unassigned volume
    # Restore the vol using its snapshot
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    #print("1 Vol restore for unassigned volume: PASS")

    ################################ 2 Vol restore after assign volume
    ports = get_two_port_diff_ctlr(ZONE)
    logger.info("Assigning vols ")
    status = vol.assign_volume(ports, hostnqn=[])
    assert (status == True)
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    #print("2 Vol restore after assign volume:PASS")

    ################################## delete s1 and its child snapshot
    #  Need to write forensic snapshots deletion code
    ################################## 3. Vol restore after 5% IO on the vol
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    #start fio on all the volumes
    logger.info("Starting write on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write([vol], host, kwargs)
    assert (status == 0)
    # Taking snaphost
    snap_name = "s2"
    logger.info("Taking snapshot :%s" % snap_name)
    snapshot = SnapShotOps(snap_name, 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": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.rand_read_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)
    assert (status == 0)
    # restore using latest snapshot
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # cheking data integrity by rading the volumes data
    # connecting the vol
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    assert (status == 0)
    print("3. Vol restore after 5% IO on the vol:PASS")

    ################################ 4. Vol restore for degraded volumes
    # Power off one drive
    mediaList = media_group.get_media_group_disk()
    media = [mediaList[0]]
    logger.info("Powering off drive : %s" % media)
    status = power_off_drive(media, pvlLibHandle)
    time.sleep(30)
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "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)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("4. Vol restore for degraded volumes:PASS")

    ################################ 5. Vol restore for critical voluems
    # poweroff one more drive
    media = [mediaList[1]]
    logger.info("Powering off drive : %s" % media)
    status = power_off_drive(media, pvlLibHandle)
    time.sleep(30)
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "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)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("5. Vol restore for critical voluems:PASS")

    ################################ 6. Vol restore with rebuild (2>1)
    # Poweron one drive and start the rebuild
    media = [mediaList[0]]
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive(media, pvlLibHandle)
    time.sleep(120)
    logger.info("Start rebuild 2>1")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "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)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("6. Vol restore with rebuild (2>1):PASS")

    ################################ 7. Vol restore with rebuild (1>0)
    media = [mediaList[1]]
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive(media, pvlLibHandle)
    time.sleep(120)
    logger.info("Start rebuild 1>0")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "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)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("7. Vol restore with rebuild (1>0):PASS")

    ################################ 8. Vol restore with rebuild (2>0)
    media = [media_group.md_disk[1], media_group.md_disk[0]]
    logger.info("Powering OFF drive : %s" % media)
    status = power_off_drive([media_group.md_disk[1], media_group.md_disk[0]],
                             pvlLibHandle)
    time.sleep(60)
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive([media_group.md_disk[1], media_group.md_disk[0]],
                            pvlLibHandle)
    time.sleep(60)
    # start rebuild
    logger.info("Start rebuild 2>0")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "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)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("8. Vol restore with rebuild (2>0):PASS")

    ################################ 9. Vol restore with clone is connected to the host
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write([vol], host, kwargs)
    assert (status == 0)
    # create clone
    clone_list = []
    clone_name = str(snap_name) + str("_c1")
    logger.info("Creating clone name : %s" % clone_name)
    cloneObj = CloneOps(clone_name, snapshot, create=True)
    clone_list.append(cloneObj)
    # assign clone
    logger.info("Assigning clone %s to contollers" % clone_name)
    assign = cloneObj.assign_clone(ports, hostnqn=[])
    # connect clone to the host
    logger.info("Connecting clone %s to the host" % clone_name)
    status = host.connect_volume(cloneObj)
    time.sleep(10)
    assert (status == 0)
    # start IO on the clone
    logger.info("Staring write IO to the clone %s" % clone_name)
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(clone_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = host.disconnect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    # restore the volumes using s2
    #status = snapshot.vol_restore()
    #assert(status == True)
    #time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = host.connect_volume(vol)
    time.sleep(10)
    assert (status == 0)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read([vol], host, kwargs)
    print("9. Vol restore with clone is connected to the host:PASS")
示例#11
0
def pds_vol_restore_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)
    ## creating mediaGroup
    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)
        #assert(drv_cnt > 8 )

    # take it from config
    md_type = 'RAID-0 (18+0)' if drv_cnt == 18 else 'RAID-6 (7+2)'
    logger.info("Creating a MediaGroup")
    md = MediaGroupOps(pvlLibHandle, name, ZONE, md_type, create=False)
    media_group = md
    assert (md != None)
    ## creaing volumes
    logger.info("Creating voluems")
    vol_list = []
    for i in range(1):
        # dont use + fro contact use %
        volname = str(VOL_PREFIX) + str("_") + str(i)
        volname = '%s_%s' % (VOL_PREFIX, i)
        vol = VolumeOps(md=media_group,
                        name=volname,
                        size=VOL_SIZE,
                        vol_res=VOL_RES,
                        flavor=FLAVOR,
                        create=False)
        vol_list.append(vol)
    #Creating a snapshot
    snap_name = "s1"
    logger.info("Creating a snapshot : %s" % snap_name)
    snapshot = SnapShotOps(snap_name, volobj=vol_list[0], create=False)
    assert (snapshot != None)

    ################################ 1 Vol restore for unassigned volume
    # Restore the vol using its snapshot
    snap_id = snapshot.snap_id
    print snap_id
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    print("1 Vol restore for unassigned volume: PASS")

    ################################ 2 Vol restore after assign volume
    ports = get_two_port_diff_ctlr(ZONE)
    logger.info("Assigning vols ")
    assign = [v.assign_volume(ports, hostnqn=[]) for v in vol_list]
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    print("2 Vol restore after assign volume:PASS")

    ################################## delete s1 and its child snapshot
    #vol,snap_list,clone_list = list_existing_obj(md.name)
    #for snap in snap_list:
    #snap_to_delete = SnapShotOps(snap,volobj=vol_list[0])
    #if snap != snap_name:
    #status = snap_to_delete.delete_snapshot
    #assert(status != None)
    #result = pvlLibHandle.storage.get_snapshot
    #print result
    #print json.dumps(result,indent=4)
    ################################## 3. Vol restore after 5% IO on the vol
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    #stert fio on all the volumes
    logger.info("Starting write on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    # Taking snaphost
    snap_name = "s2"
    logger.info("Taking snapshot :%s" % snap_name)
    snapshot = SnapShotOps(snap_name, volobj=vol_list[0], 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": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.rand_read_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconnect the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    #assert(status==0)
    # restore using latest snapshot
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    snap_id = snapshot.snap_id
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # cheking data integrity by rading the volumes data
    # connecting the vol
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    assert (status == 0)
    print("3. Vol restore after 5% IO on the vol:PASS")

    ################################ 4. Vol restore for degraded volumes
    # Power off one drive
    mediaList = media_group.get_media_group_disk()
    media = [mediaList[0]]
    logger.info("Powering off drive : %s" % media)
    status = power_off_drive(media, pvlLibHandle)
    time.sleep(30)
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("4. Vol restore for degraded volumes:PASS")

    ################################ 5. Vol restore for critical voluems
    # poweroff one more drive
    media = [mediaList[1]]
    logger.info("Powering off drive : %s" % media)
    status = power_off_drive(media, pvlLibHandle)
    time.sleep(30)
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("5. Vol restore for critical voluems:PASS")

    ################################ 6. Vol restore with rebuild (2>1)
    # Poweron one drive and start the rebuild
    media = [mediaList[0]]
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive(media, pvlLibHandle)
    time.sleep(120)
    logger.info("Start rebuild 2>1")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != None)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("6. Vol restore with rebuild (2>1):PASS")

    ################################ 7. Vol restore with rebuild (1>0)
    media = [mediaList[1]]
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive(media, pvlLibHandle)
    time.sleep(120)
    logger.info("Start rebuild 1>0")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("7. Vol restore with rebuild (1>0):PASS")

    ################################ 8. Vol restore with rebuild (2>0)
    media = [mediaList[0], mediaList[1]]
    logger.info("Powering OFF drive : %s" % media)
    status = power_off_drive(media, pvlLibHandle)
    time.sleep(120)
    logger.info("Powering ON drive : %s" % media)
    status = power_on_drive(media, pvlLibHandle)
    time.sleep(120)
    # start rebuild
    logger.info("Start rebuild 2>0")
    status = media_group.rebuild_media_group()
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("8. Vol restore with rebuild (2>0):PASS")

    ################################ 9. Vol restore with clone is connected to the host
    # overwrite on the volume
    logger.info("Starting overwrite on the vol-seq_write")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(vol_list, host, kwargs)
    assert (status == 0)
    # create clone
    clone_name = str(snap_name) + str("_c1")
    cloneObj = CloneOps(clone_name, snapshot, create=True)
    # assign clone
    assign = cloneobj.assign_clone(ports, hostnqn=[])
    # connect clone to the host
    status = host.connect_volume(cloneObj)
    assert (status != 0)
    time.sleep(5)
    # start IO on the clone
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_write(cloneObj, host, kwargs)
    assert (status == 0)
    # disconenct the vol
    logger.info("disconnecting the vol from the host")
    status = [host.disconnect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    # restore the volumes using s2
    logger.info("Running vol_restore using following snaphost : %s" %
                snap_name)
    status = pvlLibHandle.system.generic_api(
        'POST', '/storage/snapshots/%s/restore' % snap_id)
    assert (status != 200)
    time.sleep(60)
    # connect the vol & verify the data
    logger.info("connecting the vol")
    status = [host.connect_volume(v) for v in vol_list]
    assert (status != 0)
    time.sleep(5)
    logger.info("Reading from the raw device")
    kwargs = {
        'offset': "0",
        'size': '5%',
        "verify_pattern": "0xABCD",
        "verify_interval": 4096,
        "do_verify": 1
    }
    status, response = fio.seq_read(vol_list, host, kwargs)
    print("9. Vol restore with clone is connected to the host:PASS")