def drop_pool(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
pool_name = str(params['pool_name'])
disk_id = params['disk_id']
disk_part = params['disk_part']
# 删除pool
e, res = apipal.Pool().del_pool(pool_name)
if e and res.find("not added in PAL") == -1:
rc.retcode = msg_ios.RC_IOS_PAL_POOL_DROP_FAILED
rc.message = "pal pool drop failed:%s" % res
return rc, ''
time.sleep(1)
# 从pal中删除磁盘
part = common.GetPartInfo(disk_id, disk_part)
if part != None:
e, res = apipal.Disk().del_disk(part['DEVNAME'])
if e and res.find("not added in PAL") == -1:
logger.run.error("Drop pal disk failed,%s:%s:%s" %
(part['DEVNAME'], e, res))
return rc, ''
def add_lun_with_basedisk(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
disk_id = params['disk_id']
disk_part = params['disk_part']
part = common.GetPartInfo(disk_id, disk_part)
if part == None:
rc.retcode = msg_ios.RC_IOS_DISKPART_NOT_EXIST
rc.message = "part %s,%s not exist" % (disk_id, disk_part)
return rc, ''
return rc, {'DEVNAME':part['DEVNAME']}
def load_smartcache(self, params):
cache_dev = common.GetPartInfo(params['cache_disk_id'],
params['cache_disk_part'],
self.disk_list)
if cache_dev == None:
logger.run.error(
"Cann't find cache dev by uuid:%s, index:%s" %
(params['cache_disk_id'], params['cache_disk_part']))
return params, ""
data_dev = common.GetPartInfo(params['data_disk_id'],
params['data_disk_part'], self.disk_list)
if data_dev == None:
logger.run.error(
"Cann't find data dev by uuid:%s, index:%s" %
(params['data_disk_id'], params['data_disk_part']))
return params, ""
logger.run.info(
"Start load smartcache '%s'" %
(",".join(["%s:%s" % (k, v) for k, v in params.items()])))
e, res = APISmartCache().load({
'cache_dev': cache_dev['DEVNAME'],
'data_dev': data_dev['DEVNAME']
})
result = False
if e:
print res
logger.run.error(
"Load cache '%s' failed, e:%s, res:%s" %
(",".join(["%s:%s" % (k, v)
for k, v in params.items()]), e, res))
result = False
else:
result = True
return params, result
def SyncLun(self):
# 同步增加
lun_list = APISmartScsi().get_lun_list()
for lun_info in self.lun_infos:
params = {}
params["group_name"] = []
group_uuids = []
for info in lun_info.group_info:
if info.group_state:
group_uuids.append(info.group_uuid)
if lun_info.config_state == False:
continue
lun_name = "%s_%s" % (self.node_name, lun_info.lun_name)
# 过滤已经在线有组lun
if lun_name in lun_list.keys(
) and lun_list[lun_name]['attrs'].has_key(
'exported') and lun_list[lun_name]['attrs']['group_name']:
group_num = 0
for name in group_uuids:
if name in lun_list[lun_name]['attrs']["group_name"]:
continue
params["group_name"].append(name)
group_num += 1
if not group_num:
continue
# 过滤已经在线无组lun
elif lun_name in lun_list.keys(
) and lun_list[lun_name]['attrs'].has_key(
'exported'
) and not lun_list[lun_name]['attrs']['group_name']:
continue
else:
params["group_name"] = group_uuids
logger.run.info("lun group %s" % params["group_name"])
if lun_info.lun_type == msg_pds.LUN_TYPE_BASEDEV:
for basedev_info in self.basedev_infos:
if basedev_info.basedev_id == lun_info.Extensions[
msg_pds.ext_luninfo_basedev_id]:
if os.path.exists(basedev_info.dev_name):
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = basedev_info.dev_name
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
elif lun_info.lun_type == msg_pds.LUN_TYPE_BASEDISK:
for basedisk_info in self.basedisk_infos:
if basedisk_info.basedisk_id == lun_info.Extensions[
msg_pds.ext_luninfo_basedisk_id]:
part = common.GetPartInfo(basedisk_info.disk_id,
basedisk_info.disk_part,
self.disk_list)
if part != None:
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = part['DEVNAME']
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
elif lun_info.lun_type == msg_pds.LUN_TYPE_SMARTCACHE:
for smartcache_info in self.smartcache_infos:
if smartcache_info.smartcache_id == lun_info.Extensions[
msg_pds.ext_luninfo_smartcache_id]:
if os.path.exists(
os.path.join("/dev/mapper",
smartcache_info.smartcache_id)):
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = os.path.join(
"/dev/mapper", smartcache_info.smartcache_id)
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALCACHE:
for palcache_info in self.palcache_infos:
if palcache_info.palcache_id == lun_info.Extensions[
msg_pds.ext_luninfo_palcache_id]:
if os.path.exists(
os.path.join("/dev/",
palcache_info.palcache_name)):
# pal目前认到的target, target除了在dev下确认外,还需要在target list二次确认
paltarget = apipal.Target()
e, pal_targets = paltarget.get_target_list()
if e:
logger.run.error(
"Get pal target list failed:%s" %
pal_targets)
continue
ok_flag = False
for target in pal_targets:
if str(target.uuid()
) == palcache_info.palcache_id:
if apipal.testBit(target.state(),
apipal.TARGET_LOADED):
ok_flag = True
break
if ok_flag == False:
logger.run.error(
"PalCache %s status is not ok" %
palcache_info.palcache_name)
continue
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = os.path.join(
"/dev/", palcache_info.palcache_name)
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALRAW:
for palraw_info in self.palraw_infos:
if palraw_info.palraw_id == lun_info.Extensions[
msg_pds.ext_luninfo_palraw_id]:
if os.path.exists(
os.path.join("/dev/",
palraw_info.palraw_name)):
# pal目前认到的target, target除了在dev下确认外,还需要在target list二次确认
paltarget = apipal.Target()
e, pal_targets = paltarget.get_target_list()
if e:
logger.run.error(
"Get pal target list failed:%s" %
pal_targets)
continue
ok_flag = False
for target in pal_targets:
if str(target.uuid()) == palraw_info.palraw_id:
if apipal.testBit(target.state(),
apipal.TARGET_LOADED):
ok_flag = True
break
if ok_flag == False:
logger.run.error("PalRaw %s status is not ok" %
palraw_info.palraw_name)
continue
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = os.path.join(
"/dev/", palraw_info.palraw_name)
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALPMT:
for palpmt_info in self.palpmt_infos:
if palpmt_info.palpmt_id == lun_info.Extensions[
msg_pds.ext_luninfo_palpmt_id]:
if os.path.exists(
os.path.join("/dev/",
palpmt_info.palpmt_name)):
# pal目前认到的target, target除了在dev下确认外,还需要在target list二次确认
paltarget = apipal.Target()
e, pal_targets = paltarget.get_target_list()
if e:
logger.run.error(
"Get pal target list failed:%s" %
pal_targets)
continue
ok_flag = False
for target in pal_targets:
if str(target.uuid()) == palpmt_info.palpmt_id:
if apipal.testBit(target.state(),
apipal.TARGET_LOADED):
ok_flag = True
break
if ok_flag == False:
logger.run.error("PalPmt %s status is not ok" %
palpmt_info.palpmt_name)
continue
logger.run.info("Start auto load lun %s" %
(lun_info.lun_name))
params['device_name'] = "%s_%s" % (
self.node_name, lun_info.lun_name)
params['path'] = os.path.join(
"/dev/", palpmt_info.palpmt_name)
params['t10_dev_id'] = lun_info.lun_id[:23]
apismartscsi = APISmartScsi()
e = apismartscsi.add_lun(params)
if e:
logger.run.error("Add lun failed:%s" %
apismartscsi.errmsg)
break
else:
assert (0)
# 同步删除
lun_list = APISmartScsi().get_lun_list()
for lun_name in lun_list.keys():
if lun_name not in [
"%s_%s" % (self.node_name, lun_info.lun_name)
for lun_info in self.lun_infos
]:
apismartscsi = APISmartScsi()
if lun_list[lun_name]["attrs"]["group_name"]:
for k in lun_list[lun_name]["attrs"]["group_name"]:
logger.run.info("Start auto remove lun %s group %s" %
(lun_name, k))
e, exist_lun = apismartscsi.drop_lun_with_group(
lun_name, k)
if e:
logger.run.error("Drop lun failed:%s" %
apismartscsi.errmsg)
else:
logger.run.info("Start auto remove lun %s" % lun_name)
e, exist_lun = apismartscsi.drop_lun_with_group(lun_name)
if e:
logger.run.error("Drop lun failed:%s" %
apismartscsi.errmsg)
APISmartScsi().enable_targets()
return self.FinishMachine()
def PreparePal(self):
# 在同步pal的时候, 需要先刷新target-id, 以及检查模块
pal_ids = []
pal_ids.extend(
[palcache_info.pal_id for palcache_info in self.palcache_infos])
pal_ids.extend(
[palraw_info.pal_id for palraw_info in self.palraw_infos])
pal_ids.extend(
[palpmt_info.pal_id for palpmt_info in self.palpmt_infos])
common.CheckDriverConfigure(pal_ids)
palpool = apipal.Pool()
paldisk = apipal.Disk()
paltarget = apipal.Target()
# pal目前认到的磁盘
e, pal_disks = paldisk.get_disk_list()
if e:
logger.run.error("Get pal disk list failed:%s" % pal_disks)
return
pal_disks_path_name = [disk.path_name() for disk in pal_disks]
# pal目前认到的target
e, pal_targets = paltarget.get_target_list()
if e:
logger.run.error("Get pal target list failed:%s" % pal_targets)
return
pal_targets_name = [target.name() for target in pal_targets]
# pal目前认到的pool
e, pal_pools = palpool.get_pool_list()
if e:
logger.run.error("Get pal pool list failed:%s" % pal_pools)
return
pal_pools_name = [pool.name() for pool in pal_pools]
pool_id_to_info = {}
todo_load_pool_disk = []
todo_load_cache_disk = []
todo_load_raw_disk = []
todo_del_target = []
todo_del_pool = []
# 获取需要删除的垃圾target
cfg_target_name = []
cfg_target_name.extend([
palcache_info.palcache_name
for palcache_info in self.palcache_infos
])
cfg_target_name.extend(
[palraw_info.palraw_name for palraw_info in self.palraw_infos])
cfg_target_name.extend(
[palpmt_info.palpmt_name for palpmt_info in self.palpmt_infos])
for target_name in pal_targets_name:
if target_name not in cfg_target_name:
todo_del_target.append(target_name)
# 获取需要删除的垃圾pool
for pool_name in pal_pools_name:
if pool_name not in [
pool_info.pool_name for pool_info in self.pool_infos
]:
todo_del_pool.append(pool_name)
# 清理垃圾target
for target_name in todo_del_target:
logger.run.info("Auto del target %s" % target_name)
e, res = paltarget.del_target(target_name)
if e: logger.run.warning("Auto del target failed :%s" % res)
# 清理垃圾pool
for pool_name in todo_del_pool:
logger.run.info("Auto del pool %s" % pool_name)
e, res = palpool.del_pool(pool_name)
if e: logger.run.warning("Auto del pool failed :%s" % res)
# 获取pool没有load的盘
for pool_info in self.pool_infos:
pool_id_to_info[pool_info.pool_id] = pool_info
assert (len(pool_info.pool_disk_infos) == 1)
# 如果pool已经is_invalid or is_disable则不再尝试load pool的盘
if pool_info.is_invalid == True or pool_info.is_disable == True:
logger.run.info(
"Skip check pool %s disk for is invalid or is disable" %
pool_info.pool_name)
continue
pool_disk_info = pool_info.pool_disk_infos[0]
part = common.GetPartInfo(pool_disk_info.disk_id,
pool_disk_info.disk_part, self.disk_list)
if part == None:
logger.run.warning("Pal pool %s disk miss" %
pool_info.pool_name)
continue
if part['DEVNAME'] not in pal_disks_path_name:
todo_load_pool_disk.append(part['DEVNAME'])
# 获取palcache没有load的盘
for palcache_info in self.palcache_infos:
part = common.GetPartInfo(palcache_info.disk_id,
palcache_info.disk_part, self.disk_list)
if part == None:
continue
if part['DEVNAME'] not in pal_disks_path_name:
todo_load_cache_disk.append({
"dev_name": part['DEVNAME'],
"pool_id": palcache_info.pool_id
})
# 获取palraw没有load的盘
for palraw_info in self.palraw_infos:
part = common.GetPartInfo(palraw_info.disk_id,
palraw_info.disk_part, self.disk_list)
if part == None:
continue
if part['DEVNAME'] not in pal_disks_path_name:
todo_load_raw_disk.append({"dev_name": part['DEVNAME']})
# load所有pool需要load的盘
for dev_name in todo_load_pool_disk:
logger.run.info("Auto load pool disk %s" % dev_name)
e, res = paldisk.load_disk(dev_name)
if e:
logger.run.error("Load pool disk faild %s:%s" %
(dev_name, res))
# 重新获取pal目前认到的pool, 且为running状态的pool
e, pal_pools = palpool.get_pool_list()
if e:
logger.run.error("Get pal pool list failed:%s" % pal_pools)
return
loading_pal_pools_id = [
pool.uuid() for pool in pal_pools
if apipal.testBit(pool.state(), apipal.POOL_STATE_LOADING)
]
for todo_info in todo_load_cache_disk:
dev_name = todo_info['dev_name']
pool_id = todo_info['pool_id']
# 如果target对应的pool已经标记为disable, 则使用raw的方式load磁盘
if pool_id in pool_id_to_info.keys(
) and pool_id_to_info[pool_id].is_disable == True:
logger.run.info(
"Start load disk %s by raw for disable pool %s" %
(dev_name, pool_id_to_info[pool_id].pool_name))
e, res = paldisk.load_disk(dev_name, 'raw')
if e:
logger.run.error("Load cache disk faild %s:%s" %
(dev_name, res))
continue
# 如果target对应的pool已经标记为rebuild, 则使用cache的方式load磁盘
if pool_id in pool_id_to_info.keys() and pool_id_to_info[
pool_id].is_rebuild == True and pool_id_to_info[
pool_id].is_invalid == False:
logger.run.info("Start load disk %s by rebuild pool %s" %
(dev_name, pool_id_to_info[pool_id].pool_name))
e, res = paldisk.load_disk(dev_name, 'cache',
pool_id_to_info[pool_id].pool_name)
if e:
logger.run.error("Load cache disk faild %s:%s" %
(dev_name, res))
continue
# load所有target需要load的盘, 仅load target对应的pool是loading状态的target
if pool_id not in loading_pal_pools_id:
logger.run.info("Skip load disk %s by not loading pool %s" %
(dev_name, pool_id))
continue
logger.run.info("Auto load cache disk %s" % dev_name)
e, res = paldisk.load_disk(dev_name)
if e:
logger.run.error("Load cache disk faild %s:%s" %
(dev_name, res))
for todo_info in todo_load_raw_disk:
dev_name = todo_info['dev_name']
logger.run.info("Auto load raw disk %s" % dev_name)
e, res = paldisk.load_disk(dev_name)
if e:
logger.run.error("Load raw disk faild %s:%s" % (dev_name, res))
return self.SyncPoolDirtyThresh()
def add_lun_with_palraw(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
target_name = str(params['target_name'])
disk_id = params['disk_id']
disk_part = params['disk_part']
# 首先检查数据盘是否存在
part = common.GetPartInfo(disk_id, disk_part)
if part == None:
rc.retcode = msg_ios.RC_IOS_DISKPART_NOT_EXIST
rc.message = "part %s,%s not exist" % (disk_id, disk_part)
return rc, ''
if params['keep_res'] == True:
# 检查target是否存在
e, target_list = apipal.Target().get_target_list()
if e or target_name not in [target.name() for target in target_list]:
err_msg="Cann't find target %s, dev:%s, res:%s"%(target_name, part['DEVNAME'], target_list)
logger.run.error(err_msg)
rc.retcode = msg_ios.RC_IOS_PAL_TARGET_IS_INVALID
rc.message = "PAL-Target %s is invalid" % (target_name)
return rc, ''
return rc, {'DEVNAME':os.path.join("/dev", target_name)}
else:
# 添加磁盘
e, res = apipal.Disk().add_disk(part['DEVNAME'], False)
if e:
if res.find("already added in PAL") != -1:
e, res = apipal.Disk().del_disk(part['DEVNAME'])
if e:
rc.retcode = msg_ios.RC_IOS_PAL_DISK_ADD_FAILED
rc.message = "pal add disk failed :%s" % res
return rc, ''
e, res = apipal.Disk().add_disk(part['DEVNAME'], False)
if e:
rc.retcode = msg_ios.RC_IOS_PAL_DISK_ADD_FAILED
rc.message = "pal add disk failed :%s" % res
return rc, ''
else:
rc.retcode = msg_ios.RC_IOS_PAL_DISK_ADD_FAILED
rc.message = "pal add disk failed :%s" % res
return rc, ''
# 创建target
e, res = apipal.Target().add_target_palraw(target_name, part['DEVNAME'])
if e:
if res.find("target already exists") != -1:
e, res = apipal.Target().del_target(target_name)
if e:
rc.retcode = msg_ios.RC_IOS_PAL_TARGET_ADD_FAILED
rc.message = "pal add target failed :%s" % res
return rc, ''
time.sleep(2)
e, res = apipal.Target().add_target_palraw(target_name, part['DEVNAME'])
if e:
rc.retcode = msg_ios.RC_IOS_PAL_TARGET_ADD_FAILED
rc.message = "pal add target failed :%s" % res
return rc, ''
else:
rc.retcode = msg_ios.RC_IOS_PAL_TARGET_ADD_FAILED
rc.message = "pal add target failed :%s" % res
return rc, ''
# 补充pal的pal-id, 和target-id
e, target_list = apipal.Target().get_target_list()
if e:
rc.retcode = msg_ios.RC_IOS_PAL_TARGET_LIST_FAILED
rc.message = "Get target list failed:%s" % target_list
return rc, ''
target_pal_id = None
target_id = None
for target in target_list:
if str(target.name()) == str(target_name):
target_pal_id = target.id()
target_id = str(target.uuid())
break
if target_pal_id == None or target_id == None:
rc.retcode = msg_ios.RC_IOS_GET_TARGET_ID_FAILED
rc.message = "Get target id failed"
return rc, ''
return rc, {'DEVNAME':os.path.join("/dev", target_name), 'target_pal_id':target_pal_id, 'target_id':target_id}
def add_lun_with_cache(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
smartcache_id = params['smartcache_id']
data_disk_id = params['data_disk_id']
data_disk_part = params['data_disk_part']
cache_disk_id = params['cache_disk_id']
cache_disk_part = params['cache_disk_part']
# 数据盘信息
data_part = common.GetPartInfo(data_disk_id, data_disk_part)
if data_part == None:
rc.retcode = msg_ios.RC_IOS_DISKPART_NOT_EXIST
rc.message = "part %s,%s not exist" % (data_disk_id, data_disk_part)
return rc, ''
# cache盘信息
cache_part = common.GetPartInfo(cache_disk_id, cache_disk_part)
if cache_part == None:
rc.retcode = msg_ios.RC_IOS_DISKPART_NOT_EXIST
rc.message = "part %s,%s not exist" % (data_disk_id, data_disk_part)
return rc, ''
if params['keep_res'] == True:
e, smartcache_list = APISmartCache().list()
if e or smartcache_id not in smartcache_list:
err_msg="Cann't find sc %s, dev:%s, cache:%s, res:%s"%(smartcache_id,data_part['DEVNAME'],cache_part['DEVNAME'],smartcache_list)
logger.run.error(err_msg)
rc.retcode = msg_ios.RC_IOS_SMARTCACHE_IS_INVALID
rc.message = "Smartcache %s is invalid" % (smartcache_id)
return rc, ''
else:
# 检查数据盘和cache盘是否有属于某个在线的dm设备，如果有，则先卸载
e, smartcache_list = APISmartCache().list()
if not e:
for s_id in smartcache_list.keys():
e, smartcache_info = APISmartCache().info({"cache_name":s_id})
if e: continue
if smartcache_info['data_dev'] == data_part['DEVNAME'] or smartcache_info['cache_dev'] == cache_part['DEVNAME']:
logger.run.info("Dm remove smartcache %s" % s_id)
APISmartCache().dm_remove({"cache_name":s_id})
# 无论磁盘是否真的做过smartcache,都先清除下磁盘的smartcache-supperblock
APISmartCache().destroy({"cache_dev":data_part['DEVNAME']})
APISmartCache().destroy({"cache_dev":cache_part['DEVNAME']})
# 绑定smartcache
e, res = APISmartCache().create({'cache_name':smartcache_id, 'data_dev':data_part['DEVNAME'], 'cache_dev':cache_part['DEVNAME']})
if e:
err_msg="Create smartcache failed %s, dev:%s, cache:%s, msg:%s"%(smartcache_id, data_part['DEVNAME'], cache_part['DEVNAME'], res)
logger.run.error(err_msg)
rc.retcode = msg_ios.RC_IOS_CREATE_SMARTCACHE_FAILED
rc.message = "Create smartcache failed"
return rc, ''
# 获取创建出来的cache信息
e, part = APISmartCache().info({'cache_name':smartcache_id})
if e:
logger.run.error("Get smartcache info:%s failed" % smartcache_id)
rc.retcode = msg_ios.RC_IOS_LIST_SMARTCACHE_FAILED
rc.message = "Get smartcache info failed"
return rc, ''
return rc, {'DEVNAME':part['DEVNAME']}