def Entry_AddLunGroup(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
# 添加节点配置
idx = common.NewNodeName()
self.node_info.node_index = idx
self.data = pb2dict_proxy.pb2dict("nsnode_info", self.node_info)
e, _ = dbservice.srv.create("/node_list/%s" % self.node_info.node_uuid,
self.data)
if e:
logger.run.error("Create node list faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
node = msg_pds.NSNodeInfoConf()
node.node_uuid = self.node_info.node_uuid
node.node_info.CopyFrom(self.node_info)
g.nsnode_conf_list.nsnode_infos.add().CopyFrom(node)
# 如果 指定组将节点加入到组中
if self.group_name:
request = MakeRequest(msg_mds.NODE_CONFIG_REQUEST)
request.body.Extensions[
msg_mds.
node_config_request].node_index = self.node_info.node_index
request.body.Extensions[
msg_mds.node_config_request].group_name = self.group_name
self.SendInternalRequest(request, self.Entry_ConfigAdd)
return MS_CONTINUE
def Entry_OnlineLun(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
self.lun_info.config_state = True
self.lun_info.actual_state = True
self.lun_info.last_heartbeat_time = int(time.time())
data = pb2dict_proxy.pb2dict("lun_info", self.lun_info)
e, _ = dbservice.srv.update("/lun/%s" % self.lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
lun_info = common.GetLunInfoByName(self.lun_info.lun_name)
lun_info.CopyFrom(self.lun_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_OfflineLun(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
num = int(
response.body.Extensions[msg_ios.lun_drop_response].exist_lun)
logger.run.info("After do action offline lun export num [%s]" % num)
if num:
self.lun_info.config_state = True
else:
self.lun_info.config_state = False
self.lun_info.ClearExtension(msg_mds.ext_luninfo_lun_export_info)
data = pb2dict_proxy.pb2dict("lun_info", self.lun_info)
e, _ = dbservice.srv.update("/lun/%s" % self.lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
lun_info = common.GetLunInfoByName(self.lun_info.lun_name)
lun_info.CopyFrom(self.lun_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.GROUP_DEL_RESPONSE, request)
self.request = request
self.request_body = request.body.Extensions[msg_mds.group_del_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
self.group_name = self.request_body.group_name
node_index = self.request_body.node_index
error, self.node_uuid = common.GetUUIDFromIndex(node_index)
if error:
self.response.rc.retcode = msg_mds.RC_MDS_NODE_FIND_FAIL
self.response.rc.message = "Not find %s" % node_index
self.SendResponse(self.response)
return MS_FINISH
error, self.group_info = common.GetGroupInfoFromName(self.group_name)
if error:
self.response.rc.retcode = msg_mds.RC_MDS_GROUP_FIND_FAIL
self.response.rc.message = "Not found group %s" % self.group_name
self.SendResponse(self.response)
return MS_FINISH
if not self.node_uuid in self.group_info.node_uuids:
self.response.rc.retcode = msg_mds.RC_MDS_NODE_FIND_FAIL
self.response.rc.message = "Not find %s in %s" % (node_index,
self.group_name)
self.SendResponse(self.response)
return MS_FINISH
# 更新lun信息
# 如果已经存在node计数 >= 2则减1
self.task_info = []
for lun_info in g.lun_list.lun_infos:
if self.group_name in lun_info.group_name:
for group_info in lun_info.group_info:
if self.node_uuid == group_info.group_uuid and group_info.group_state >= 2:
group_info.group_state -= 1
data = pb2dict_proxy.pb2dict("lun_info", lun_info)
e, _ = dbservice.srv.update(
"/lun/%s" % lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" %
(e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 如果已经存在node计数=1offline此节点
elif self.node_uuid == group_info.group_uuid and group_info.group_state == 1:
self.task_info.append(lun_info)
if self.task_info:
return self.Do_Task()
else:
return self.Update_Group_Config()
def Entry_AddLunPalPmt(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
palpmt_info = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_palpmt]
palpmt_info.pal_id = response.body.Extensions[
msg_ios.lun_add_response].target_pal_id
palpmt_info.palpmt_id = response.body.Extensions[
msg_ios.lun_add_response].target_id
palpmt_info.size = (palpmt_info.size << 30) / 512
# 将palpmt配置信息持久化
data = pb2dict_proxy.pb2dict("palpmt_info", palpmt_info)
e, _ = dbservice.srv.create("/palpmt/%s" % palpmt_info.palpmt_id, data)
if e:
logger.run.error("Create palpmt faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
g.palpmt_list.palpmt_infos.add().CopyFrom(palpmt_info)
return self.CreateLunMetaData()
def CreateLunMetaData(self):
lun_info = msg_pds.LunInfo()
lun_info.lun_id = self.ios_request_body.lun_id
lun_info.lun_name = self.ios_request_body.lun_name
lun_info.lun_type = self.ios_request_body.lun_type
lun_info.config_state = True
lun_info.actual_state = True
lun_info.last_heartbeat_time = int(time.time())
if self.group_uuid:
for k in self.group_uuid:
info = lun_info.group_info.add()
info.group_uuid = k
info.group_state = 1
lun_info.group_name.extend([self.request_body.group_name])
if lun_info.lun_type == msg_pds.LUN_TYPE_SMARTCACHE:
smartcache_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_smartcache].smartcache_id
lun_info.Extensions[
msg_pds.ext_luninfo_smartcache_id] = smartcache_id
elif lun_info.lun_type == msg_pds.LUN_TYPE_BASEDISK:
basedisk_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_basedisk].basedisk_id
lun_info.Extensions[msg_pds.ext_luninfo_basedisk_id] = basedisk_id
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALCACHE:
palcache_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_palcache].palcache_id
lun_info.Extensions[msg_pds.ext_luninfo_palcache_id] = palcache_id
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALRAW:
palraw_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_palraw].palraw_id
lun_info.Extensions[msg_pds.ext_luninfo_palraw_id] = palraw_id
elif lun_info.lun_type == msg_pds.LUN_TYPE_PALPMT:
palpmt_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_palpmt].palpmt_id
lun_info.Extensions[msg_pds.ext_luninfo_palpmt_id] = palpmt_id
elif lun_info.lun_type == msg_pds.LUN_TYPE_BASEDEV:
basedev_id = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_basedev].basedev_id
lun_info.Extensions[msg_pds.ext_luninfo_basedev_id] = basedev_id
# 将lun配置信息持久化
data = pb2dict_proxy.pb2dict("lun_info", lun_info)
e, _ = dbservice.srv.create("/lun/%s" % lun_info.lun_id, data)
if e:
logger.run.error("Create lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 更新lun列表
g.lun_list.lun_infos.add().CopyFrom(lun_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.UNLINK_QOS_TEMPLATE_RESPONSE, request)
self.request = request
self.request_body = request.body.Extensions[msg_mds.unlink_qos_template_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
items = self.request_body.lun_name.split("_")
if len(items) != 2 or items[0] != g.node_info.node_name:
self.response.rc.retcode = msg_mds.RC_MDS_LUN_NOT_EXIST
self.response.rc.message = "Lun '%s' is not exist" % self.request_body.lun_name
self.SendResponse(self.response)
return MS_FINISH
self.lun_name = items[1]
# 获取lun信息
lun_info = common.GetLunInfoByName(self.lun_name)
if lun_info == None:
self.response.rc.retcode = msg_mds.RC_MDS_LUN_NOT_EXIST
self.response.rc.message = "Lun '%s' is not exist" % self.lun_name
self.SendResponse(self.response)
return MS_FINISH
if lun_info.qos_template_id == "":
self.response.rc.retcode = msg_mds.RC_MDS_LUN_NOT_LINKED
self.response.rc.message = "Lun '%s' is not linked qos template" % self.lun_name
self.SendResponse(self.response)
return MS_FINISH
self.lun_info = msg_pds.LunInfo()
self.lun_info.CopyFrom(lun_info)
self.lun_info.qos_template_id = ""
self.lun_info.qos_template_name = ""
# 将lun配置信息持久化
data = pb2dict_proxy.pb2dict("lun_info",self.lun_info)
e, _ = dbservice.srv.update("/lun/%s" % self.lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 更新lun列表
lun_info.CopyFrom(self.lun_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Update_Group_Config(self):
self.group_info.node_uuids.extend([self.node_uuid])
data = pb2dict_proxy.pb2dict("group_info", self.group_info)
e, _ = dbservice.srv.update("/group_list/%s"%self.group_name, data)
if e:
logger.run.error("Update node list faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.QOS_TEMPLATE_ADD_RESPONSE,
request)
self.request = request
self.request_body = request.body.Extensions[
msg_mds.qos_template_add_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
self.template_name = self.request_body.template_name
self.template_info = common.GetQosTemplateInfoByName(
self.template_name)
if self.template_info:
self.response.rc.retcode = msg_mds.RC_MDS_QOS_TEMPLATE_ALREADY_ADDED
self.response.rc.message = "QoS '%s' is already added" % self.template_name
self.SendResponse(self.response)
return MS_FINISH
template_info = msg_pds.QosTemplateInfo()
template_info.template_name = self.template_name
template_info.template_id = str(uuid.uuid1())
template_info.qos_info.read_bps = self.request_body.qos_info.read_bps
template_info.qos_info.read_iops = self.request_body.qos_info.read_iops
template_info.qos_info.write_bps = self.request_body.qos_info.write_bps
template_info.qos_info.write_iops = self.request_body.qos_info.write_iops
# 将QoS模板信息持久化
data = pb2dict_proxy.pb2dict("template_info", template_info)
e, _ = dbservice.srv.create(
"/qostemplate/%s" % template_info.template_id, data)
if e:
logger.run.error("Add template faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 更新QoS模板列表
g.qos_template_list.qos_template_infos.add().CopyFrom(template_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.QOS_TEMPLATE_UPDATE_RESPONSE,
request)
self.request = request
self.request_body = request.body.Extensions[
msg_mds.qos_template_update_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
self.template_name = self.request_body.template_name
template_info = common.GetQosTemplateInfoByName(self.template_name)
if not template_info:
self.response.rc.retcode = msg_mds.RC_MDS_QOS_TEMPLATE_NOT_EXIST
self.response.rc.message = "QoS '%s' is not exist" % self.template_name
self.SendResponse(self.response)
return MS_FINISH
self.template_info = msg_pds.QosTemplateInfo()
self.template_info.CopyFrom(template_info)
self.template_info.qos_info.read_bps = self.request_body.qos_info.read_bps or template_info.qos_info.read_bps
self.template_info.qos_info.read_iops = self.request_body.qos_info.read_iops or template_info.qos_info.read_iops
self.template_info.qos_info.write_bps = self.request_body.qos_info.write_bps or template_info.qos_info.write_bps
self.template_info.qos_info.write_iops = self.request_body.qos_info.write_iops or template_info.qos_info.write_iops
# 将QoS模板信息持久化
data = pb2dict_proxy.pb2dict("template_info", self.template_info)
e, _ = dbservice.srv.update(
"/qostemplate/%s" % self.template_info.template_id, data)
if e:
logger.run.error("Update template faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 更新内存
template_info.CopyFrom(self.template_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_ConfigPoolSkipThresh(self, skip_thresh):
pool_info = msg_pds.PoolInfo()
pool_info.CopyFrom(self.pool_info)
pool_info.skip_thresh = self.request_body.skip_thresh
data = pb2dict_proxy.pb2dict("pool_info", pool_info)
e, _ = dbservice.srv.update("/pool/%s" % pool_info.pool_id, data)
if e:
logger.run.error("Update pool info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
self.pool_info.CopyFrom(pool_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_DropLunGroup(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
e, node_list = dbservice.srv.delete("/node_list/%s" % self.node_uuid)
if e:
logger.run.error("delete list info faild %s:%s" % (e, node_list))
self.response.rc.retcode = msg_mds.RC_MDS_DELETE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 同配置文件全局更新
node_list = msg_mds.G_NSNodeConfList()
for node_info in filter(
lambda node_info: node_info.node_uuid != self.node_uuid,
g.nsnode_conf_list.nsnode_infos):
node_list.nsnode_infos.add().CopyFrom(node_info)
g.nsnode_conf_list = node_list
#同一节点可以在多个组中
group_info = msg_pds.GroupInfoConf()
for group in g.group_list.groups:
if self.node_uuid in group.node_uuids:
group_info.CopyFrom(group)
group_info.remove(self.node_uuid)
data = pb2dict_proxy.pb2dict("group_info", group_info)
e, _ = dbservice.srv.update(
"/group_list/%s" % group.group_name, data)
if e:
logger.run.error("Update node list faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
group.remove(self.node_uuid)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_DiskAdd(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
# 初始化后的盘信息
disk_info = response.body.Extensions[
msg_ios.disk_add_response].disk_info
# 设置磁盘逻辑id
if self.request_body.HasField('disk_name'):
disk_info.disk_name = self.request_body.disk_name
else:
disk_info.disk_name = common.NewDiskName(self.disk_type)
disk_info.actual_state = True
disk_info.disk_type = self.disk_type
disk_info.last_heartbeat_time = int(time.time())
for diskpart in disk_info.diskparts:
diskpart.actual_state = True
diskpart.last_heartbeat_time = int(time.time())
if self.raid_disk_info != None:
disk_info.raid_disk_info.CopyFrom(self.raid_disk_info)
# 将磁盘配置信息持久化
data = pb2dict_proxy.pb2dict("disk_info", disk_info)
e, _ = dbservice.srv.create("/disk/%s" % disk_info.header.uuid, data)
if e:
logger.run.error("Create disk faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 更新磁盘列表
g.disk_list.disk_infos.add().CopyFrom(disk_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_AddLunSmartCache(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
smartcache_info = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_smartcache]
# 将smartcache配置信息持久化
data = pb2dict_proxy.pb2dict("smartcache_info", smartcache_info)
e, _ = dbservice.srv.create(
"/smartcache/%s" % smartcache_info.smartcache_id, data)
if e:
logger.run.error("Create smartcache faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
g.smartcache_list.smartcache_infos.add().CopyFrom(smartcache_info)
return self.CreateLunMetaData()
def Entry_AddLunBaseDisk(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
basedisk_info = self.ios_request_body.Extensions[
msg_ios.ext_lunaddrequest_basedisk]
# 将磁盘配置信息持久化
data = pb2dict_proxy.pb2dict("basedisk_info", basedisk_info)
e, _ = dbservice.srv.create("/basedisk/%s" % basedisk_info.basedisk_id,
data)
if e:
logger.run.error("Create basedisk faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
g.basedisk_list.basedisk_infos.add().CopyFrom(basedisk_info)
return self.CreateLunMetaData()
def Entry_OnlineLun(self, response,ios=True):
if ios:
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
self.lun_info.config_state = True
self.lun_info.actual_state = True
self.lun_info.last_heartbeat_time = int(time.time())
if self.add_groups:
for k in self.add_groups:
info = self.lun_info.group_info.add()
info.group_uuid = k
info.group_state = 1
if self.add_common_groups:
for info in self.lun_info.group_info:
if info.group_uuid in self.add_common_groups:
info.group_state += 1
self.lun_info.group_name.extend([self.request_body.group_name])
data = pb2dict_proxy.pb2dict("lun_info", self.lun_info)
e, _ = dbservice.srv.update("/lun/%s" % self.lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
lun_info = common.GetLunInfoByName(self.lun_info.lun_name)
lun_info.CopyFrom(self.lun_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_AddPool(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
# 将Pool配置信息持久化
pool_info = self.ios_request.body.Extensions[
msg_ios.pool_add_request].pool_info
pool_info.pool_id = response.body.Extensions[
msg_ios.pool_add_response].pool_id
pool_info.is_variable = self.request_body.is_variable
pool_info.actual_state = True
pool_info.last_heartbeat_time = int(time.time())
data = pb2dict_proxy.pb2dict("pool_info", pool_info)
e, _ = dbservice.srv.create("/pool/%s" % pool_info.pool_id, data)
if e:
logger.run.error("Create pool faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
# 及时更新pool导出信息，换盘需要
pool_export_info = response.body.Extensions[
msg_ios.pool_add_response].ext_poolinfo_pool_export_info
pool_info.Extensions[msg_mds.ext_poolinfo_pool_export_info].CopyFrom(
pool_export_info)
# 更新内存pool列表
g.pool_list.pool_infos.add().CopyFrom(pool_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def Entry_AddPool(self, response):
if response.rc.retcode != msg_pds.RC_SUCCESS:
self.response.rc.CopyFrom(response.rc)
self.SendResponse(self.response)
return MS_FINISH
# 补充创建回来的pool-id
new_pool_info = self.ios_request.body.Extensions[
msg_ios.pool_add_request].pool_info
new_pool_info.pool_id = response.body.Extensions[
msg_ios.pool_add_response].pool_id
new_pool_info.is_rebuild = True
new_pool_info.actual_state = True
new_pool_info.last_heartbeat_time = int(time.time())
# 创建新的pool info
data = pb2dict_proxy.pb2dict("pool_info", new_pool_info)
e, _ = dbservice.srv.create("/pool/%s" % new_pool_info.pool_id, data)
if e:
logger.run.error("Create pool faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
g.pool_list.pool_infos.add().CopyFrom(new_pool_info)
# 更新所有老的palcache的pool id为新的pool id
ok_flag = True
for palcache_info in filter(
lambda palcache_info: palcache_info.pool_id == self.pool_info.
pool_id, g.palcache_list.palcache_infos):
_palcache_info = msg_pds.PalCacheInfo()
_palcache_info.CopyFrom(palcache_info)
# 替换为新的pool-id
_palcache_info.pool_id = new_pool_info.pool_id
# 更新配置
data = pb2dict_proxy.pb2dict("palcache_info", _palcache_info)
e, _ = dbservice.srv.update(
"/palcache/%s" % _palcache_info.palcache_id, data)
if e:
logger.run.error("Update palcache %s info faild %s:%s" %
(_palcache_info.palcache_id, e, _))
ok_flag = False
continue
# 更新内存
palcache_info.CopyFrom(_palcache_info)
# 删除老的pool info
if ok_flag == True:
e, _ = dbservice.srv.delete("/pool/%s" % self.pool_info.pool_id)
if e:
logger.run.error("Delete pool info faild %s:%s" % (e, _))
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
pool_list = msg_mds.G_PoolList()
for pool_info in filter(
lambda pool_info: pool_info.pool_id != self.pool_info.
pool_id, g.pool_list.pool_infos):
pool_list.pool_infos.add().CopyFrom(pool_info)
g.pool_list = pool_list
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.SET_POOL_DISABLE_RESPONSE,
request)
self.request = request
self.request_body = request.body.Extensions[
msg_mds.set_pool_disable_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
self.pool_info = common.GetPoolInfoByName(self.request_body.pool_name)
if self.pool_info == None:
self.response.rc.retcode = msg_mds.RC_MDS_POOL_NOT_EXIST
self.response.rc.message = "Pool %s not exist" % self.request_body.pool_name
self.SendResponse(self.response)
return MS_FINISH
if self.pool_info.is_disable == True:
self.response.rc.retcode = msg_mds.RC_MDS_ERROR_PARAMS
self.response.rc.message = "Pool %s already disabled" % self.request_body.pool_name
self.SendResponse(self.response)
return MS_FINISH
# pool如果在线, 则不准许disable
if self.pool_info.actual_state == True:
self.response.rc.retcode = msg_mds.RC_MDS_NOT_SUPPORT
self.response.rc.message = "Not support set disable to a online pool"
self.SendResponse(self.response)
return MS_FINISH
# 如果pool下有palcache是在线状态, 则不准许disable
for palcache_info in g.palcache_list.palcache_infos:
if palcache_info.pool_id == self.pool_info.pool_id and palcache_info.actual_state == True:
self.response.rc.retcode = msg_mds.RC_MDS_INTERNAL_ERROR
self.response.rc.message = "Not support set disable to this pool for exist available palcache"
self.SendResponse(self.response)
return MS_FINISH
# 如果pool之前没有更新is_invalid字段, 需要先更新
pool_info = msg_pds.PoolInfo()
pool_info.CopyFrom(self.pool_info)
if pool_info.is_invalid != True:
pool_info.is_invalid = True
data = pb2dict_proxy.pb2dict("pool_info", pool_info)
e, _ = dbservice.srv.update("/pool/%s" % pool_info.pool_id, data)
if e:
logger.run.error("Update pool info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
logger.run.info("Set pool %s to invalid" %
self.request_body.pool_name)
pool_info.is_disable = True
self.pool_info.CopyFrom(pool_info)
logger.run.info("Set pool %s to diable" % self.request_body.pool_name)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.NODE_CONFIG_RESPONSE, request)
self.request = request
self.request_body = request.body.Extensions[msg_mds.node_config_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
if self.request_body.HasField("node_index") and self.request_body.HasField("group_name"):
node_index = self.request_body.node_index
self.group_name = self.request_body.group_name
error,self.node_uuid = common.GetUUIDFromIndex(node_index)
if error:
self.response.rc.retcode = msg_mds.RC_MDS_NODE_FIND_FAIL
self.response.rc.message = "Not find %s" %node_index
self.SendResponse(self.response)
return MS_FINISH
error,self.group_info = common.GetGroupInfoFromName(self.group_name)
if error:
self.response.rc.retcode = msg_mds.RC_MDS_GROUP_FIND_FAIL
self.response.rc.message = "Not found group %s"% self.group_name
self.SendResponse(self.response)
return MS_FINISH
if self.node_uuid in self.group_info.node_uuids:
self.response.rc.retcode = msg_mds.RC_MDS_NODE_FIND_FAIL
self.response.rc.message = "Node %s already in group %s" % (node_index,self.group_name)
self.SendResponse(self.response)
return MS_FINISH
# 更新lun信息
# 如果已经存在node则直接更新配置计数
found = 0
for lun_info in g.lun_list.lun_infos:
if self.group_name in lun_info.group_name:
for group_info in lun_info.group_info:
if self.node_uuid == group_info.group_uuid:
group_info.group_state +=1
data = pb2dict_proxy.pb2dict("lun_info", lun_info)
e, _ = dbservice.srv.update("/lun/%s" % lun_info.lun_id, data)
if e:
logger.run.error("Update lun info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
found += 1
# 如果不存在需要上线该节点
if not found:
self.task_info = []
for lun_info in g.lun_list.lun_infos:
if self.group_name in lun_info.group_name:
self.task_info.append(lun_info)
return self.Do_Task()
else:
return self.Update_Group_Config()
elif self.request_body.HasField('node_name'):
node_info = msg_pds.NodeInfo()
node_info.CopyFrom(g.node_info)
# TODO: 补充node-name个数和字符的合法性检查
if len(self.request_body.node_name) > 5:
self.response.rc.retcode = msg_mds.RC_MDS_ERROR_PARAMS
self.response.rc.message = "Node name max len is 5"
self.SendResponse(self.response)
return MS_FINISH
# 检查当前是否有在线的lun
if len([lun_info for lun_info in g.lun_list.lun_infos if lun_info.config_state==True]) != 0:
self.response.rc.retcode = msg_mds.RC_MDS_REFUSE_CONFIG_NODE_NAME
self.response.rc.message = "Please offline all luns before config node name"
self.SendResponse(self.response)
return MS_FINISH
node_info.node_name = self.request_body.node_name
data = pb2dict_proxy.pb2dict("node_info", node_info)
# 首次配置的时候, 配置文件中还没有node-info
e, _ = dbservice.srv.get("/node_info")
if e == dbclient.RC_ERR_NODE_NOT_EXIST:
e, _ = dbservice.srv.create("/node_info", data)
if e:
logger.run.error("Create node info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_CREATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
else:
e, _ = dbservice.srv.update("/node_info", data)
if e:
logger.run.error("Update node info faild %s:%s" % (e, _))
self.response.rc.retcode = msg_mds.RC_MDS_UPDATE_DB_DATA_FAILED
self.response.rc.message = "Keep data failed"
self.SendResponse(self.response)
return MS_FINISH
g.node_info.CopyFrom(node_info)
# 更新广播全局节点列表
for nsnode_info in g.nsnode_list.nsnode_infos:
if nsnode_info.node_uuid == g.node_uuid:
nsnode_info.node_name = node_info.node_name
else:
self.response.rc.retcode = msg_mds.RC_MDS_ERROR_PARAMS
self.response.rc.message = "params error"
self.SendResponse(self.response)
return MS_FINISH
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
def INIT(self, request):
self.response = MakeResponse(msg_mds.HEARTBEAT_TARGET_LIST_RESPONSE,
request)
self.request = request
self.request_body = request.body.Extensions[
msg_mds.heartbeat_target_list_request]
if g.is_ready == False:
self.response.rc.retcode = msg_mds.RC_MDS_SERVICE_IS_NOT_READY
self.response.rc.message = "MDS service is not ready"
self.SendResponse(self.response)
return MS_FINISH
palcache_export_list = {}
palraw_export_list = {}
palpmt_export_list = {}
for target_export_info in self.request_body.target_export_infos:
if target_export_info.type == msg_pds.TARGET_TYPE_CACHE:
palcache_export_list[
target_export_info.target_id] = target_export_info
if target_export_info.type == msg_pds.TARGET_TYPE_RAW:
palraw_export_list[
target_export_info.target_id] = target_export_info
if target_export_info.type == msg_pds.TARGET_TYPE_PMT:
palpmt_export_list[
target_export_info.target_id] = target_export_info
# palcache
for palcache_info in g.palcache_list.palcache_infos:
if palcache_info.palcache_id in palcache_export_list.keys():
if palcache_info.actual_state == False:
logger.run.info(
'[NODE STATE]: change palcache %s actual state to True'
% palcache_info.palcache_id)
palcache_info.actual_state = True
palcache_info.last_heartbeat_time = int(time.time())
palcache_info.Extensions[
msg_mds.ext_palcache_export_info].CopyFrom(
palcache_export_list[palcache_info.palcache_id])
# 检查palcache pal-id, 如果变更,需要更新配置文件
if not palcache_info.HasField('pal_id'):
continue
if palcache_info.pal_id != palcache_export_list[
palcache_info.palcache_id].pal_id:
logger.run.info("Start update palcache %s pal id" %
palcache_info.palcache_id)
_palcache_info = msg_pds.PalCacheInfo()
_palcache_info.CopyFrom(palcache_info)
_palcache_info.pal_id = palcache_export_list[
palcache_info.palcache_id].pal_id
data = pb2dict_proxy.pb2dict("palcache_info",
_palcache_info)
e, _ = dbservice.srv.update(
"/palcache/%s" % _palcache_info.palcache_id, data)
if e:
logger.run.error(
"Update palcache pal id %s info faild %s:%s" %
(_palcache_info.palcache_id, e, _))
continue
palcache_info.CopyFrom(_palcache_info)
# palraw
for palraw_info in g.palraw_list.palraw_infos:
if palraw_info.palraw_id in palraw_export_list.keys():
if palraw_info.actual_state == False:
logger.run.info(
'[NODE STATE]: change palraw %s actual state to True' %
palraw_info.palraw_id)
palraw_info.actual_state = True
palraw_info.last_heartbeat_time = int(time.time())
palraw_info.Extensions[
msg_mds.ext_palraw_export_info].CopyFrom(
palraw_export_list[palraw_info.palraw_id])
# 检查palraw pal-id, 如果变更,需要更新配置文件
if not palraw_info.HasField('pal_id'):
continue
if palraw_info.pal_id != palraw_export_list[
palraw_info.palraw_id].pal_id:
logger.run.info("Start update palraw %s pal id" %
palraw_info.palraw_id)
_palraw_info = msg_pds.PalRawInfo()
_palraw_info.CopyFrom(palraw_info)
_palraw_info.pal_id = palraw_export_list[
palraw_info.palraw_id].pal_id
data = pb2dict_proxy.pb2dict("palraw_info", _palraw_info)
e, _ = dbservice.srv.update(
"/palraw/%s" % _palraw_info.palraw_id, data)
if e:
logger.run.error(
"Update palraw pal id %s info faild %s:%s" %
(_palraw_info.palraw_id, e, _))
continue
palraw_info.CopyFrom(_palraw_info)
# palpmt
for palpmt_info in g.palpmt_list.palpmt_infos:
if palpmt_info.palpmt_id in palpmt_export_list.keys():
if palpmt_info.actual_state == False:
logger.run.info(
'[NODE STATE]: change palpmt %s actual state to True' %
palpmt_info.palpmt_id)
palpmt_info.actual_state = True
palpmt_info.last_heartbeat_time = int(time.time())
palpmt_info.Extensions[
msg_mds.ext_palpmt_export_info].CopyFrom(
palpmt_export_list[palpmt_info.palpmt_id])
# 检查palpmt pal-id, 如果变更,需要更新配置文件
if not palpmt_info.HasField('pal_id'):
continue
if palpmt_info.pal_id != palpmt_export_list[
palpmt_info.palpmt_id].pal_id:
logger.run.info("Start update palpmt %s pal id" %
palpmt_info.palpmt_id)
_palpmt_info = msg_pds.PalPmtInfo()
_palpmt_info.CopyFrom(palpmt_info)
_palpmt_info.pal_id = palpmt_export_list[
palpmt_info.palpmt_id].pal_id
data = pb2dict_proxy.pb2dict("palpmt_info", _palpmt_info)
e, _ = dbservice.srv.update(
"/palpmt/%s" % _palpmt_info.palpmt_id, data)
if e:
logger.run.error(
"Update palpmt pal id %s info faild %s:%s" %
(_palpmt_info.palpmt_id, e, _))
continue
palpmt_info.CopyFrom(_palpmt_info)
self.response.rc.retcode = msg_pds.RC_SUCCESS
self.SendResponse(self.response)
return MS_FINISH
