def online_asmdisk(self, params={}):
rc = msg_pds.ResponseCode()
ret, dbs = asm.get_grid_env()
if ret:
logger.run.error("Parse oratab env failed: %s" % dbs)
rc.retcode = msg_mds.RC_MDS_GET_GRID_ENV_FAILED
return rc, None
if dbs.has_key("grid_home"):
grid_home = dbs["grid_home"]
else:
logger.run.error("Can not find Oracle grid home")
rc.retcode = msg_mds.RC_MDS_GET_GRID_ENV_FAILED
return rc, None
sql = AsmOraSQLPlus(grid_home)
if self.asmdisk_name:
ret, result = sql.online_asm_disk(self.diskgroup_name,
self.asmdisk_name)
else:
ret, result = sql.online_asm_disk(self.diskgroup_name,
failgroup=self.failgroup)
if ret:
logger.run.error("ASMDisk online failed: %s" % result)
rc.retcode = msg_mds.RC_MDS_ASMDISK_ONLINE_FAILED
return rc, None
logger.run.info("ASMDisk %s online success" % self.asmdisk_name)
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
def get_slot_list(self, params={}):
rc = msg_pds.ResponseCode()
# 获取槽位、bus address列表
ret, slot_address = self.get_slot_address()
if ret:
rc.retcode = msg_ios.RC_IOS_GET_SLOT_LIST_FAILED
rc.message = "Get slot list failed: %s" % slot_address
return rc, None
# 分别获取宝存卡、镁光ssd设备名、raid卡、华为nvme和对应的bus address
ret1, address_device_shannon = self.get_shannon_address_device()
ret2, address_device_micron = self.get_micron_address_device()
ret3, address_device_raid = self.get_raid_address_device()
ret4, address_device_huawei = self.get_huawei_address_device()
slot_list = []
for slot, address in slot_address.items():
slot_info = msg_pds.SlotInfo()
slot_info.slot_id = slot
slot_info.bus_address = address
if not ret1 and address in address_device_shannon:
slot_info.dev_name = address_device_shannon[address]
if not ret2 and address in address_device_micron:
slot_info.dev_name = address_device_micron[address]
if not ret3 and address in address_device_raid:
slot_info.dev_name = address_device_raid[address]
if not ret4 and address in address_device_huawei:
slot_info.dev_name = address_device_huawei[address]
slot_list.append(slot_info)
return rc, slot_list
def Entry_LunActive(self, response):
rc = msg_pds.ResponseCode()
if response.rc.retcode != msg_pds.RC_SUCCESS:
# 向另外的计算节点发送请求，全部失败才返回
if self.request_num < len(self.database_node_list):
self.request_num += 1
return self.send_asm_request()
else:
if self.lun_info.asm_status == "OFFLINE":
logger.run.error(response.rc.message)
rc.retcode = response.rc.retcode
return rc, None
else:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
else:
# 有一个请求成功则直接返回
if self.lun_info.asm_status == "OFFLINE":
logger.run.info("Lun %s active success" %
self.request_body.lun_name)
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
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 Entry_LunOffline(self, response):
rc = msg_pds.ResponseCode()
if response.rc.retcode != msg_pds.RC_SUCCESS:
logger.run.error(response.rc.message)
rc.retcode = response.rc.retcode
return rc, None
return self.drop_lun()
def add_lun_with_basedev(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
if not os.path.exists(params['dev_name']):
rc.retcode = msg_ios.RC_IOS_DEV_NOT_EXIST
rc.message = "Device %s not exist" % params['dev_name']
return rc, ''
return rc, {'DEVNAME':params['dev_name']}
def add_lun_with_palpmt(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
target_name = str(params['target_name'])
pool_name = params['pool_name']
size = params['size']
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, res:%s"%(target_name, 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:
# 创建target
e, res = apipal.Target().add_target_palpmt(target_name, pool_name, size)
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_palpmt(target_name, pool_name, size)
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 Entry_LunOnline(self, response):
rc = msg_pds.ResponseCode()
if response.rc.retcode != msg_pds.RC_SUCCESS:
logger.run.error(response.rc.message)
rc.retcode = response.rc.retcode
return rc, None
self.LongWork(self.active_lun, {})
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
def Entry_LunDrop(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
if self.lun_info.asm_status == "ACTIVE":
rc = msg_pds.ResponseCode()
logger.run.error(response.rc.message)
rc.retcode = response.rc.retcode
return rc, None
else:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
return self.LunDropMetaData()
def check_disk_available(self, disk_part_name):
# disk_part_name : hdNpM
rc = msg_pds.ResponseCode()
if len(disk_part_name.split('p')) != 2:
rc.retcode = msg_mds.RC_MDS_ERROR_PARAMS
rc.message = "Disk name '%s' is not legal, please use 'hdNpM'" % disk_part_name
return rc, None
disk_part = disk_part_name.split('p')[1]
disk_name = disk_part_name.split('p')[0]
if not disk_part.isdigit():
rc.retcode = msg_mds.RC_MDS_ERROR_PARAMS
rc.message = "Disk name '%s' is not legal" % disk_part_name
return rc, None
disk_part = int(disk_part)
# 检查磁盘是否存在
disk_info = common.GetDiskInfoByName(disk_name)
if disk_info == None:
rc.retcode = msg_mds.RC_MDS_DISK_NOT_EXIST
rc.message = "Disk '%s' is not exist" % disk_name
return rc, None
# 检查分区是否存在
if len([
diskpart for diskpart in disk_info.diskparts
if diskpart.disk_part == disk_part
]) == 0:
rc.retcode = msg_mds.RC_MDS_DISK_PART_NOT_EXIST
rc.message = "Disk %s's part %s is not exist" % (disk_name,
disk_part)
return rc, None
# 检查磁盘分区是否有被POOL使用过
pool_info = common.GetPoolInfoByDiskPart(disk_info.header.uuid,
disk_part)
if pool_info != None:
rc.retcode = msg_mds.RC_MDS_DISK_PART_IS_IN_USED
rc.message = "Disk '%s' is used by Pool:'%s'" % (
disk_part_name, pool_info.pool_name)
return rc, None
# 检查磁盘是否已经创建过lun
lun_info = common.GetLunInfoByDiskPart(disk_info.header.uuid,
disk_part)
if lun_info != None:
rc.retcode = msg_mds.RC_MDS_DISK_PART_IS_IN_USED
rc.message = "Disk '%s' is used by Lun:'%s'" % (disk_part_name,
lun_info.lun_name)
return rc, None
rc.retcode = msg_pds.RC_SUCCESS
return rc, disk_info
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 rescan_scsi_bus(self, params):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
# 如果有扫描进程, 则不再扫描
e, out = command(
"/usr/bin/ps -elf | grep smartstore_srp_rescan_scsi_bus.sh | grep -v grep"
)
if out.find("smartstore_srp_rescan_scsi_bus") != -1:
return rc, None
command("/usr/bin/smartstore_srp_rescan_scsi_bus.sh --offline")
command("/usr/bin/smartstore_srp_rescan_scsi_bus.sh --online")
return rc, None
def check_pool_available(self, pool_name):
# pool_name : pool01
rc = msg_pds.ResponseCode()
# 检查pool是否存在
pool_info = common.GetPoolInfoByName(pool_name)
if pool_info == None:
rc.retcode = msg_mds.RC_MDS_POOL_NOT_EXIST
rc.message = "Pool '%s' is not exist" % pool_name
return rc, None
# 检查pool是否在线
if pool_info.actual_state == False:
rc.retcode = msg_mds.RC_MDS_POOL_NOT_AVAILABLE
rc.message = "Pool %s is not available" % pool_name
return rc, None
rc.retcode = msg_pds.RC_SUCCESS
return rc, pool_info
def rebalance_wait(self, params={}):
rc = msg_pds.ResponseCode()
while True:
time.sleep(1)
lun_info = common.GetLunInfoByName(self.lun_name)
if lun_info.asm_status != "DROPPING":
break
if lun_info.asm_status == "HUNG":
logger.run.error("Lun drop faild: asm drop filed because disk space not enough")
rc.retcode = msg_mds.RC_MDS_LUN_DROP_FAILED
return rc, None
self.LongWork(self.offline_lun, {})
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
def active_lun(self, params={}):
rc = msg_pds.ResponseCode()
time.sleep(5)
lun_info = common.GetLunInfoByName(self.lun_name)
if lun_info.asm_status != "INACTIVE":
logger.run.error(
"[Lun Active] lun %s online success, but active failed! because it not in asm group."
% self.request_body.lun_name)
rc.retcode = msg_mds.RC_MDS_LUN_ACTIVE_NOT_ALLOWED
return rc, None
self.mds_database_request = MakeRequest(msg_mds.ASMDISK_ONLINE_REQUEST)
asmdisk_info = common.GetASMDiskInfoByLunName(
self.request_body.lun_name)
self.mds_database_request.body.Extensions[
msg_mds.asmdisk_online_request].asmdisk_name = asmdisk_info.dskname
# 先向第一个计算节点发送请求
self.request_num = 1
return self.send_asm_request()
def send_broadcast(self, params={}):
rc = msg_pds.ResponseCode()
rc.retcode = msg_pds.RC_SUCCESS
ncard = config.safe_get('model-config', 'discover-ncard')
nip = common.get_ip_address(ncard)
if nip == None:
logger.run.error("Can't get ip from :%s" % ncard)
return rc, []
data = {"action": "discover", "broadcast_version": g.broadcast_version}
smartmon_ip = config.safe_get('network', 'listen-ip')
if g.is_smartmon == True:
data.update({"smartmon_ip": smartmon_ip})
data = json.dumps(data)
data = struct.pack('I', len(data)) + data
host = "%s.0" % ".".join(nip.split(".")[:3])
desc = (host, config.safe_get_int('model-config', 'discover-port'))
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
sock.settimeout(2)
sock.sendto(data, desc)
data_nsnode = []
try:
data = ""
while True:
data += sock.recv(1024)
if len(data) >= (pkSize +
struct.unpack('I', data[:pkSize])[0]):
_data = data[pkSize:pkSize +
struct.unpack('I', data[:pkSize])[0]]
data_nsnode.append(_data)
data = data[pkSize + struct.unpack('I', data[:pkSize])[0]:]
except socket.timeout as e:
pass
sock.close()
return rc, data_nsnode
def recv_file_and_storage(self, request_body):
rc = msg_pds.ResponseCode()
if request_body.HasField(
'first_upload') and request_body.first_upload == True:
if not os.path.isdir(g.bak_dir):
os.makedirs(g.bak_dir)
try:
for _file in request_body.fileinfo:
node_name = request_body.node_name + "_" + request_body.listen_ip
node_dir = os.path.join(g.bak_dir, node_name)
if not os.path.isdir(node_dir):
os.mkdir(node_dir)
ret, version = self.get_file_verison(
node_dir, _file.file_name)
local_time = time.strftime('%Y%m%d%H',
time.localtime(time.time()))
file_name = _file.file_name + "_" + str(
local_time) + "_" + str(version)
file_name = os.path.join(node_dir, file_name)
content = base64.decodestring(_file.file_content)
with open(file_name, 'wb') as f:
f.write(content)
f.close()
except:
logger.run.error("Recv upload file from %s error" %
request_body.node_name)
rc.retcode = msg_mds.RC_MDS_UPLOAD_FILE_FAIL
return rc, None
logger.run.info("Recv upload file from %s success" %
request_body.node_name)
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
elif request_body.HasField(
'first_upload') and request_body.first_upload == False:
if not os.path.isdir(g.second_bak_dir):
os.makedirs(g.second_bak_dir)
try:
for _file in request_body.fileinfo:
ret, version = self.get_file_verison(
g.second_bak_dir, _file.file_name)
local_time = time.strftime('%Y%m%d%H',
time.localtime(time.time()))
file_name = _file.file_name + "_" + str(
local_time) + "_" + str(version)
file_name = os.path.join(g.second_bak_dir, file_name)
content = base64.decodestring(_file.file_content)
with open(file_name, 'wb') as f:
f.write(content)
f.close()
except:
logger.run.error("Recv second upload file from %s error" %
request_body.node_name)
rc.retcode = msg_mds.RC_MDS_UPLOAD_FILE_FAIL
return rc, None
logger.run.info("Recv second upload file from %s success" %
request_body.node_name)
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
def LunDropMetaData(self):
rc = msg_pds.ResponseCode()
if self.lun_info.lun_type == msg_pds.LUN_TYPE_SMARTCACHE:
smartcache_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_smartcache].smartcache_id
e, _ = dbservice.srv.delete("/smartcache/%s" % smartcache_id)
if e:
logger.run.error("Delete smartcache info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
smartcache_list = msg_mds.G_SmartCacheList()
for smartcache_info in filter(lambda smartcache_info:smartcache_info.smartcache_id!=smartcache_id,g.smartcache_list.smartcache_infos):
smartcache_list.smartcache_infos.add().CopyFrom(smartcache_info)
g.smartcache_list = smartcache_list
elif self.lun_info.lun_type == msg_pds.LUN_TYPE_BASEDISK:
basedisk_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_basedisk].basedisk_id
e, _ = dbservice.srv.delete("/basedisk/%s" % basedisk_id)
if e:
logger.run.error("Delete basedisk info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
basedisk_list = msg_mds.G_BaseDiskList()
for basedisk_info in filter(lambda basedisk_info:basedisk_info.basedisk_id!=basedisk_id,g.basedisk_list.basedisk_infos):
basedisk_list.basedisk_infos.add().CopyFrom(basedisk_info)
g.basedisk_list = basedisk_list
elif self.lun_info.lun_type == msg_pds.LUN_TYPE_BASEDEV:
basedev_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_basedev].basedev_id
e, _ = dbservice.srv.delete("/basedev/%s" % basedev_id)
if e:
logger.run.error("Delete basedev info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
basedev_list = msg_mds.G_BaseDevList()
for basedev_info in filter(lambda basedev_info:basedev_info.basedev_id!=basedev_id,g.basedev_list.basedev_infos):
basedev_list.basedev_infos.add().CopyFrom(basedev_info)
g.basedev_list = basedev_list
elif self.lun_info.lun_type == msg_pds.LUN_TYPE_PALCACHE:
palcache_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_palcache].palcache_id
e, _ = dbservice.srv.delete("/palcache/%s" % palcache_id)
if e:
logger.run.error("Delete palcache info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
palcache_list = msg_mds.G_PalCacheList()
for palcache_info in filter(lambda palcache_info:palcache_info.palcache_id!=palcache_id,g.palcache_list.palcache_infos):
palcache_list.palcache_infos.add().CopyFrom(palcache_info)
g.palcache_list = palcache_list
elif self.lun_info.lun_type == msg_pds.LUN_TYPE_PALRAW:
palraw_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_palraw].palraw_id
e, _ = dbservice.srv.delete("/palraw/%s" % palraw_id)
if e:
logger.run.error("Delete palraw info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
palraw_list = msg_mds.G_PalRawList()
for palraw_info in filter(lambda palraw_info:palraw_info.palraw_id!=palraw_id,g.palraw_list.palraw_infos):
palraw_list.palraw_infos.add().CopyFrom(palraw_info)
g.palraw_list = palraw_list
elif self.lun_info.lun_type == msg_pds.LUN_TYPE_PALPMT:
palpmt_id = self.ios_request_body.Extensions[msg_ios.ext_lundroprequest_palpmt].palpmt_id
e, _ = dbservice.srv.delete("/palpmt/%s" % palpmt_id)
if e:
logger.run.error("Delete palpmt info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
palpmt_list = msg_mds.G_PalPmtList()
for palpmt_info in filter(lambda palpmt_info:palpmt_info.palpmt_id!=palpmt_id,g.palpmt_list.palpmt_infos):
palpmt_list.palpmt_infos.add().CopyFrom(palpmt_info)
g.palpmt_list = palpmt_list
else:
assert(0)
e, _ = dbservice.srv.delete("/lun/%s" % self.lun_info.lun_id)
if e:
logger.run.error("Delete lun info faild %s:%s" % (e, _))
if self.lun_info.asm_status == "ACTIVE":
rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
return rc, None
else:
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Drop data failed"
self.SendResponse(self.response)
return MS_FINISH
# 从内存中删除该Lun
lun_list = msg_mds.G_LunList()
for lun_info in filter(lambda lun_info:lun_info.lun_id!=self.lun_info.lun_id,g.lun_list.lun_infos):
lun_list.lun_infos.add().CopyFrom(lun_info)
g.lun_list = lun_list
if self.lun_info.asm_status == "ACTIVE":
logger.run.info("Lun %s drop success" % self.request_body.lun_name)
rc.retcode = msg_pds.RC_SUCCESS
return rc, None
self.response.body.Extensions[msg_mds.lun_drop_response].drop_success = True
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
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 get_disk_list(self, params={}):
todo_check_disk = []
rc = msg_pds.ResponseCode()
# 获取megaraid磁盘列表
e, disk_list = MegaRaid().get_disk_list()
if e:
rc.retcode = msg_ios.RC_IOS_GET_DISK_LIST
rc.message = "Get megaraid disk list failed : %s" % disk_list
return rc, ''
for disk in disk_list:
raid_disk_info = msg_pds.RaidDiskInfo()
raid_disk_info.raid_type = msg_pds.RAID_TYPE_MEGARAID
raid_disk_info.ctl = str(disk['ctl'])
raid_disk_info.eid = disk['eid']
raid_disk_info.slot = disk['slot']
raid_disk_info.drive_type = disk['drive_type']
raid_disk_info.protocol = disk['protocol']
raid_disk_info.pci_addr = disk['pci_addr']
raid_disk_info.size = disk['size']
raid_disk_info.model = disk['model']
raid_disk_info.state = disk['state']
if disk.has_key('dev_name') and disk['dev_name'] != "":
raid_disk_info.dev_name = disk['dev_name']
_disk = {}
_disk['did'] = disk['did']
_disk['raid_type'] = "megaraid"
_disk['dev_name'] = disk['dev_name']
_disk['drive_type'] = disk['drive_type']
todo_check_disk.append(_disk)
_raid_disk_info = self.mds_request.body.Extensions[
msg_mds.heartbeat_disk_list_request].raid_disk_infos.add()
_raid_disk_info.CopyFrom(raid_disk_info)
# 获取sas2raid磁盘列表
e, disk_list = SAS2Raid().get_disk_list()
if e:
rc.retcode = msg_ios.RC_IOS_GET_DISK_LIST
rc.message = "Get sas2raid disk list failed : %s" % disk_list
return rc, ''
for disk in disk_list:
raid_disk_info = msg_pds.RaidDiskInfo()
raid_disk_info.raid_type = msg_pds.RAID_TYPE_SAS2RAID
raid_disk_info.ctl = str(disk['ctl'])
raid_disk_info.eid = disk['eid']
raid_disk_info.slot = disk['slot']
raid_disk_info.drive_type = disk['drive_type']
raid_disk_info.protocol = disk['protocol']
raid_disk_info.pci_addr = disk['pci_addr']
raid_disk_info.size = disk['size']
raid_disk_info.model = disk['model']
raid_disk_info.state = disk['state']
if disk.has_key('dev_name') and disk['dev_name'] != "":
raid_disk_info.dev_name = disk['dev_name']
_disk = {}
_disk['raid_type'] = "sas2raid"
_disk['did'] = None
_disk['dev_name'] = disk['dev_name']
_disk['drive_type'] = disk['drive_type']
todo_check_disk.append(_disk)
_raid_disk_info = self.mds_request.body.Extensions[
msg_mds.heartbeat_disk_list_request].raid_disk_infos.add()
_raid_disk_info.CopyFrom(raid_disk_info)
# 获取hpsaraid磁盘列表
e, disk_list = HPSARaid().get_disk_list()
if e:
rc.retcode = msg_ios.RC_IOS_GET_DISK_LIST
rc.message = "Get hpsaraid disk list failed : %s" % disk_list
return rc, ''
Suffix = 1
for disk in disk_list:
raid_disk_info = msg_pds.RaidDiskInfo()
raid_disk_info.raid_type = msg_pds.RAID_TYPE_HPSARAID
raid_disk_info.ctl = disk['ctl']
raid_disk_info.eid = disk['eid']
raid_disk_info.slot = disk['slot']
raid_disk_info.drive_type = disk['drive_type']
raid_disk_info.protocol = disk['protocol']
raid_disk_info.pci_addr = disk['pci_addr']
raid_disk_info.size = disk['size']
raid_disk_info.model = disk['model']
raid_disk_info.state = disk['state']
if disk.has_key('dev_name') and disk['dev_name'] != "":
raid_disk_info.dev_name = disk['dev_name']
# 判断是否逻辑盘符相同
same_name = False
for d in todo_check_disk:
if d['dev_name'] == disk['dev_name']:
same_name = True
_disk = {}
if same_name == True:
_disk['dev_name'] = "%s%s" % (disk['dev_name'], Suffix)
Suffix = Suffix + 1
else:
_disk['dev_name'] = disk['dev_name']
_disk['raid_type'] = "cciss"
_disk['did'] = disk['slot'] - 1
_disk['slot'] = disk['slot']
_disk['drive_type'] = disk['drive_type']
_disk['serial1'] = disk['Serial']
todo_check_disk.append(_disk)
_raid_disk_info = self.mds_request.body.Extensions[
msg_mds.heartbeat_disk_list_request].raid_disk_infos.add()
_raid_disk_info.CopyFrom(raid_disk_info)
# 获取系统认到的磁盘列表
e, disk_list = APIDisk().get_disk_list()
if e:
rc.retcode = msg_ios.RC_IOS_GET_DISK_LIST
rc.message = "Get disk list failed : %s" % disk_list
return rc, ''
for disk in disk_list:
disk_info = self.mds_request.body.Extensions[
msg_mds.heartbeat_disk_list_request].disk_infos.add()
if disk.has_key('DEVNAME') and disk['DEVNAME'] != "":
if disk.has_key('drive_type') and disk['drive_type'] == "nvme":
_disk = {}
_disk['dev_name'] = disk['DEVNAME']
_disk['drive_type'] = disk['drive_type']
todo_check_disk.append(_disk)
if disk.has_key(
'drive_type') and disk['drive_type'] == "df_pcie":
_disk = {}
_disk['dev_name'] = disk['DEVNAME']
_disk['drive_type'] = disk['drive_type']
todo_check_disk.append(_disk)
disk_info.dev_name = disk['DEVNAME']
disk_info.size = disk['SIZE']
if disk.has_key('HEADER'):
disk_info.header.uuid = disk['HEADER']['uuid']
for part in disk['PARTS']:
diskpart = disk_info.diskparts.add()
diskpart.disk_part = int(part['INDEX'])
diskpart.size = part['SIZE']
diskpart.dev_name = part['DEVNAME']
return rc, todo_check_disk
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']}
