def get_dctype_by_net_area_id(self, net_area_id):
net_area_data = n_a_s.NetAreaService().get_net_area_info(net_area_id)
datacenter_id = net_area_data['datacenter_id']
datacenter_data = DataCenterService().get_datacenter_info(
datacenter_id)
dc_type = datacenter_data['dc_type']
return dc_type
def net_area_delete():
net_area_ids = request.values.get('net_area_ids')
if not net_area_ids:
logging.error('no net_area_ids when delete net area')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
net_area_ids_list = net_area_ids.split(',')
# 操作的net area数
all_num = len(net_area_ids_list)
msg = None
fail_num = 0
for _id in net_area_ids_list:
# 有集群和网段的都不能删除
_hostpool_num = hostpool_s.HostPoolService(
).get_hostpool_nums_in_net_area(_id)
if _hostpool_num > 0:
logging.error('no allow to delete net area %s that has hostpool',
_id)
fail_num += 1
# 单台操作且已失败则直接跳出循环
if all_num == 1:
msg = '该网络区域下已分配有集群，不允许删除'
break
continue
_segment_num = segment_s.SegmentService().get_segment_nums_in_net_area(
_id)
if _segment_num > 0:
logging.error(
'no allow to delete net area %s that has network segment', _id)
fail_num += 1
# 单台操作且已失败则直接跳出循环
if all_num == 1:
msg = '该网络区域下已分配有网段，不允许删除'
break
continue
_ret = net_area_s.NetAreaService().delete_net_area(_id)
if _ret <= 0:
logging.error('db delete net area %s fail when delete net area',
_id)
fail_num += 1
continue
# 全失败
if fail_num == all_num:
logging.error("delete net area all failed")
if msg:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=msg)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 部分成功
if 0 < fail_num < all_num:
logging.error("delete all %s net area part %s failed", all_num,
fail_num)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS_PART,
msg="部分网络区域删除成功")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def datacenter_delete():
datacenter_ids = request.values.get('datacenter_ids')
if not datacenter_ids:
logging.error('no datacenter_ids when delete datacenter')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
datacenter_ids_list = datacenter_ids.split(',')
# 操作的datacenter数
all_num = len(datacenter_ids_list)
msg = None
fail_num = 0
for _id in datacenter_ids_list:
_net_area_nums = net_area_s.NetAreaService().get_net_area_nums_in_dc(
_id)
if _net_area_nums > 0:
logging.error('no allow to delete datacenter %s that has net area',
_id)
fail_num += 1
# 单台操作且已失败则直接跳出循环
if all_num == 1:
msg = '该机房下已分配有网络区域，不允许删除'
break
continue
_ret = dc_s.DataCenterService().delete_datacenter(_id)
if _ret <= 0:
logging.error(
'db delete datacenter %s fail when delete datacenter', _id)
fail_num += 1
continue
_dc_info = dc_s.DataCenterService().get_datacenter_info(_id)
if not _dc_info:
logging.error(
'datacenter info %s is not exist in db when delete datacenter',
_id)
fail_num += 1
continue
# 把该机房的主机名增量值清空
incre_s.clean_dc_increment_value(_dc_info['name'])
# 全失败
if fail_num == all_num:
logging.error("delete datacenter all failed")
if msg:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=msg)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 部分成功
if 0 < fail_num < all_num:
logging.error("delete all %s datacenter part %s failed", all_num,
fail_num)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS_PART,
msg="部分机房删除成功")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def ip_resource_display_to_other_platform_new():
'''
将kvm已有的网段展示给其他平台新接口，查询指定网段可用的ip数量
:return:
'''
data_from_vishnu = request.data
logging.info(data_from_vishnu)
data_requset = json_helper.loads(data_from_vishnu)
req_datacenter = data_requset['dataCenter']
req_env = data_requset['env']
req_net_area = data_requset['netArea']
req_net_name = data_requset['netName']
# 校验入参是否为空
if not req_env or not req_net_area or not req_net_name or not req_datacenter:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail='入参有空值')
# 查询指定环境、网络区域是否有所需网段
ret_segment = segment_service.SegmentService().get_segment_info_bysegment(req_net_name.split('/')[0])
if not ret_segment:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail="无法找到需要申请的网段")
ret_net_area_info = net_area.NetAreaService().get_net_area_info(ret_segment['net_area_id'])
if not ret_net_area_info:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail="无法找到指定网段所属网络区域信息")
ret_datacenter_info = datacenter_service.DataCenterService().get_datacenter_info(
ret_net_area_info['datacenter_id'])
if not ret_datacenter_info:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail="无法找到指定机房信息")
if req_env not in DataCenterTypeForVishnu.TYPE_DICT:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail="无法找到指定机房类型信息")
if str(DataCenterTypeForVishnu.TYPE_DICT[req_env]) != ret_datacenter_info['dc_type']:
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.FAILED, detail="无法找到指定网络区域对应网段信息")
# 获取可用ip
ret_ip_available_status, ret_ip_available = ip_service.get_all_available_segment_ip(ret_segment['id'], str(
DataCenterTypeForVishnu.TYPE_DICT[req_env]))
if not ret_ip_available_status:
ret_params = {
"ip_num": 0
}
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.SUCCEED, detail=ret_params)
ret_params = {
"ip_num": len(ret_ip_available)
}
return json_helper.format_api_resp_msg_to_vishnu_resource(job_status=VsJobStatus.SUCCEED, detail=ret_params)
def ip_instance_info():
'''
获取IP分配给VM的详细信息
:return:
'''
ip_address = request.values.get('ip_address')
if not ip_address:
logging.info('no ip_address when get ip info')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ip_info = ip_s.IPService().get_ip_info_by_ipaddress(ip_address)
if not ip_info:
logging.error('IP %s info no exist in db when get ip info', ip_address)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 检查ip是否为应用vip
vip_info = vip_s.VIPService().get_vip_by_id(ip_info['id'])
if not vip_info:
if ip_info['status'] != IPStatus.USED:
logging.info('IP %s status %s is not used when get ip info',
ip_address, ip_info['status'])
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="IP状态不对，不能查看IP详细信息")
ip_instance_data = ip_s.get_instance_info_by_ip(ip_address)
if ip_instance_data:
instance_name = ip_instance_data.get('instance_name', None)
datacenter_name = ip_instance_data.get('datacenter_name', None)
net_area_name = ip_instance_data.get('net_area_name', None)
else:
instance_name = None
datacenter_name = None
net_area_name = None
ip_data = {
'ip_address': ip_address,
'datacenter': datacenter_name,
'net_area': net_area_name,
'instance_name': instance_name,
'gateway': ip_info['gateway_ip'],
'netmask': ip_info['netmask'],
'vlan': ip_info['vlan'],
'service_id': '',
'is_vip': '0'
}
else:
segment_info = segment_s.SegmentService().get_segment_info(
ip_info['segment_id'])
if not segment_info:
_msg = '无法获取IP：%s的网段信息' % ip_address
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=_msg)
net_area_info = net_area.NetAreaService().get_net_area_info(
segment_info['net_area_id'])
if not net_area_info:
net_area_name = ''
net_area_name = net_area_info['name']
datacenter_info = datacenter_service.DataCenterService(
).get_datacenter_info(net_area_info['datacenter_id'])
if not datacenter_info:
datacenter_name = ''
datacenter_name = datacenter_info['name']
ip_data = {
'ip_address': ip_address,
'datacenter': datacenter_name,
'net_area': net_area_name,
'instance_name': '',
'gateway': ip_info['gateway_ip'],
'netmask': ip_info['netmask'],
'vlan': ip_info['vlan'],
'sys_code': vip_info['sys_code'],
'is_vip': '1'
}
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, data=ip_data)
def ip_apply_from_other_platform():
'''
外部平台申请ip
:return:
'''
data_from_vishnu = request.data
logging.info(data_from_vishnu)
data_requset = json_helper.loads(data_from_vishnu)
req_datacenter = data_requset['datacenter']
req_env = data_requset['env']
req_net_area = data_requset['net_area']
req_net_name = data_requset['net_name']
cluster_id = data_requset['cluster_id']
opuser = data_requset['opUser']
sys_code = data_requset['sys_code']
taskid_vs = data_requset['taskid']
ip_count = data_requset['ipCount']
prd_dr_ip_all_needed = data_requset['prdDrAllNeeded'] # '0'代表普通申请，'1'需要同时申请prd、dr环境的ip
# 校验入参是否为空
if not req_env or not req_net_area or not req_net_name or not req_datacenter:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='empty input of env, net area information or net name '
'when apply ip')
if not cluster_id or not opuser or not sys_code or not taskid_vs:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='empty input of cluster_id, opuser, '
'task id or sys_code when apply ip')
if not str(ip_count) or not str(prd_dr_ip_all_needed):
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='empty input of ipCount or prdDrAllNeeded when apply ip')
# 查询指定环境、网络区域是否有所需网段
ret_segment = segment_service.SegmentService().get_segment_info_bysegment(req_net_name.split('/')[0])
if not ret_segment:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail="无法找到需要申请的网段")
ret_net_area_info = net_area.NetAreaService().get_net_area_info(ret_segment['net_area_id'])
if not ret_net_area_info:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail="无法找到指定网段所属网络区域信息")
ret_datacenter_info = datacenter_service.DataCenterService().get_datacenter_info(ret_net_area_info['datacenter_id'])
if not ret_datacenter_info:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail="无法找到指定机房信息")
if req_env not in DataCenterTypeForVishnu.TYPE_DICT:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail="无法找到指定机房类型信息")
if str(DataCenterTypeForVishnu.TYPE_DICT[req_env]) != ret_datacenter_info['dc_type']:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail="无法找到指定网络区域对应网段信息")
# 如果是申请生产或者容灾环境ip，需判断网段对应关系表中是否有记录
if req_env == 'PRD':
segment_dr = segment_m.SegmentMatchService().get_segment_match_info_by_prd_segment_id(
ret_segment['id'])
if not segment_dr:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下无法找到生产网段对应的容灾网段ID')
segment_dr_data = segment_s.SegmentService().get_segment_info(segment_dr['dr_segment_id'])
if not segment_dr_data:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下无法找到生产网段对应的容灾网段详细信息')
elif req_env == 'DR':
segment_prd = segment_m.SegmentMatchService().get_segment_match_info_by_dr_segment_id(
ret_segment['id'])
if not segment_prd:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下无法找到容灾网段对应的生产网段ID')
segment_prd_data = segment_s.SegmentService().get_segment_info(segment_prd['prd_segment_id'])
if not segment_prd_data:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下无法找到容灾网段对应的生产网段详细信息')
# 获取IP资源，先判断是否有人也在分配IP资源，有则等待1s，时间之后再优化
ip_lock_unused = False
while not ip_lock_unused:
ret_ip_lock_status = ip_l_s.IpLockService().get_ip_lock_info('ip')
if not ret_ip_lock_status:
logging.error('外部接口分配vip：检查IP时无法获取资源锁状态')
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='检查IP时无法获取资源锁状态')
if ret_ip_lock_status['istraceing'] == IpLockStatus.USED:
time.sleep(1)
else:
ip_lock_unused = True
# 更新ip_lock表istraceing字段为1
ret_ip_lock_used_status, ret_ip_lock_used_datas = __update_ip_lock_used()
if not ret_ip_lock_used_status:
logging.error(ret_ip_lock_used_datas)
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail=ret_ip_lock_used_datas)
try:
segments_data_list = []
segments_data_list.append(ret_segment)
# 获取可用ip
ret_ip_datas, ret_ip_segment_datas = ip_service.get_available_ips(segments_data_list, int(ip_count), str(
DataCenterTypeForVishnu.TYPE_DICT[req_env]))
if not ret_ip_datas:
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused()
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail=ret_ip_lock_unused_datas)
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下无法找到%s个可用IP' % str(ip_count))
# 标记ip为预分配
logging.info(ret_ip_datas)
ips_list = []
prd_ips_list = []
dr_ips_list = []
ip_details = {}
for ip in ret_ip_datas:
update_data = {
'status': IPStatus.USED
}
where_data = {
'id': ip['id']
}
ret_mark_ip = ip_service.IPService().update_ip_info(update_data, where_data)
if ret_mark_ip <= 0:
continue
# 录入vip信息到数据库中
insert_vip_data = {
'ip_id': ip['id'],
'cluster_id': cluster_id,
'apply_user_id': opuser,
'sys_code': sys_code,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret_vip = vip_service.VIPService().add_vip_info(insert_vip_data)
if ret_vip.get('row_num') <= 0:
continue
ip_datas = {
'ip': ip['ip_address'],
'vlanId': ip['vlan'],
'subnetMask': __exchange_maskint(int(ip['netmask'])),
'gateway': ip['gateway_ip']
}
ips_list.append(ip_datas)
# 生产环境需要预分配对应容灾环境ip，容灾环境需要预分配生产环境ip
if req_env == 'PRD':
# 拼凑虚拟机容灾ip并预分配ip
dr_ip = segment_dr_data['segment'].split('.')[0] + '.' + segment_dr_data['segment'].split('.')[1] + \
'.' + ip['ip_address'].split('.')[2] + '.' + ip['ip_address'].split('.')[3]
dr_ip_info = ip_service.IPService().get_ip_by_ip_address(dr_ip)
# 如果容灾环境ip未初始化，默认初始化
if not dr_ip_info:
if not __init_ip(segment_dr_data, dr_ip):
continue
dr_ip_info = ip_service.IPService().get_ip_by_ip_address(dr_ip)
if prd_dr_ip_all_needed == '1':
update_data = {
'status': IPStatus.USED
}
where_data = {
'id': dr_ip_info['id']
}
ret_mark_ip = ip_service.IPService().update_ip_info(update_data, where_data)
if ret_mark_ip <= 0:
continue
# 录入vip信息到数据库中
insert_vip_data = {
'ip_id': dr_ip_info['id'],
'cluster_id': cluster_id,
'apply_user_id': opuser,
'sys_code': sys_code,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret_vip = vip_service.VIPService().add_vip_info(insert_vip_data)
if ret_vip.get('row_num') <= 0:
continue
else:
update_data = {
'status': IPStatus.PRE_ALLOCATION
}
where_data = {
'ip_address': dr_ip
}
ret_mark_ip = ip_service.IPService().update_ip_info(update_data, where_data)
if ret_mark_ip <= 0:
continue
# 拼装容灾ip信息
dr_ip_datas = {
'ip': dr_ip_info['ip_address'],
'vlanId': dr_ip_info['vlan'],
'subnetMask': __exchange_maskint(int(dr_ip_info['netmask'])),
'gateway': dr_ip_info['gateway_ip']
}
dr_ips_list.append(dr_ip_datas)
elif req_env == 'DR':
# 拼凑虚拟机生产ip并预分配ip
prd_ip = segment_prd_data['segment'].split('.')[0] + '.' + segment_prd_data['segment'].split('.')[1] + \
'.' + ip['ip_address'].split('.')[2] + '.' + ip['ip_address'].split('.')[3]
prd_ip_info = ip_service.IPService().get_ip_by_ip_address(prd_ip)
# 如果生产环境ip未初始化，默认初始化
if not prd_ip_info:
if not __init_ip(segment_prd_data, prd_ip):
continue
prd_ip_info = ip_service.IPService().get_ip_by_ip_address(prd_ip)
if prd_dr_ip_all_needed == '1':
update_data = {
'status': IPStatus.USED
}
where_data = {
'id': prd_ip_info['id']
}
ret_mark_ip = ip_service.IPService().update_ip_info(update_data, where_data)
if ret_mark_ip <= 0:
continue
# 录入vip信息到数据库中
insert_vip_data = {
'ip_id': prd_ip_info['id'],
'cluster_id': cluster_id,
'apply_user_id': opuser,
'sys_code': sys_code,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret_vip = vip_service.VIPService().add_vip_info(insert_vip_data)
if ret_vip.get('row_num') <= 0:
continue
else:
update_data = {
'status': IPStatus.PRE_ALLOCATION
}
where_data = {
'ip_address': prd_ip
}
ret_mark_ip = ip_service.IPService().update_ip_info(update_data, where_data)
if ret_mark_ip <= 0:
continue
# 拼装生产ip信息
prd_ip_datas = {
'ip': prd_ip_info['ip_address'],
'vlanId': prd_ip_info['vlan'],
'subnetMask': __exchange_maskint(int(prd_ip_info['netmask'])),
'gateway': prd_ip_info['gateway_ip']
}
prd_ips_list.append(prd_ip_datas)
except Exception as e:
_msg = '外部平台申请IP：预分配ip出现异常: distribution ip exception，err：%s'%e
logging.error(_msg)
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused()
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=_msg)
# 更新ip_lock表istraceing字段为0
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused()
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail=ret_ip_lock_unused_datas)
if len(ips_list) <= 0:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下%s个可用IP修改为预分配状态全部失败' % str(ip_count))
elif req_env == 'PRD' and (len(ips_list) + len(dr_ips_list)) < int(ip_count) * 2:
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS_PART, job_status=VsJobStatus.FAILED,
detail='生产环境指定机房、网络区域下%s个可用IP修改为预分配状态部分失败' % str(ip_count))
elif req_env == 'DR' and (len(ips_list) + len(prd_ips_list)) < int(ip_count) * 2:
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS_PART, job_status=VsJobStatus.FAILED,
detail='容灾环境指定机房、网络区域下%s个可用IP修改为预分配状态部分失败' % str(ip_count))
elif len(ips_list) < int(ip_count):
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS_PART, job_status=VsJobStatus.FAILED,
detail='指定机房、网络区域下%s个可用IP修改为预分配状态部分失败' % str(ip_count))
else:
if req_env == 'PRD':
ip_details['prd'] = ips_list
ip_details['dr'] = dr_ips_list
elif req_env == 'DR':
ip_details['dr'] = ips_list
ip_details['prd'] = prd_ips_list
else:
ip_details['default'] = ips_list
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS, job_status=VsJobStatus.SUCCEED,
detail=ip_details)
def net_area_add():
datacenter_id = request.values.get('datacenter_id')
name = request.values.get('name')
imagecache01 = request.values.get('imagecache01')
imagecache02 = request.values.get('imagecache02')
if not name or not datacenter_id or not imagecache01 or not imagecache02:
logging.info('no area_name or datacenter_id when add net_area')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
dc_data = dc_s.DataCenterService().get_datacenter_info(datacenter_id)
if not dc_data:
logging.error('datacenter %s no exist in db when add net_area',
datacenter_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 同一环境下机房下的网络区域不能重名
name_exist = net_area_s.check_name_exist_in_same_dc_type(
name, dc_data['dc_type'])
if name_exist:
logging.error('name %s in dc_type %s is duplicated when add net_area',
name, dc_data['dc_type'])
return json_helper.format_api_resp(code=ErrorCode.DUPLICATED_ERR,
msg='同环境机房下的网络区域名不能重复，请修改网络区域名')
# 两台imagecache不能重复
if imagecache01 == imagecache02:
logging.info('imagecache address duplicated')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="镜像缓存服务器地址重复")
insert_data = {
'datacenter_id': datacenter_id,
'name': name,
'displayname': name,
'created_at': get_datetime_str(),
}
ret = net_area_s.NetAreaService().add_net_area(insert_data)
if ret == -1:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
net_area_id = ret.get('last_id')
insert_imagecache01 = {
"net_area_id": net_area_id,
"imagecache_ip": imagecache01,
"create_at": get_datetime_str()
}
ret = imca_s.ImageCacheService().add_imagecache_info(insert_imagecache01)
if ret.get('row_num') <= 0:
logging.error("add imagecache01 error, insert_data:%s",
str(insert_data))
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="新增cache01地址失败")
insert_imagecache02 = {
"net_area_id": net_area_id,
"imagecache_ip": imagecache02,
"create_at": get_datetime_str()
}
ret = imca_s.ImageCacheService().add_imagecache_info(insert_imagecache02)
if ret.get('row_num') <= 0:
logging.error("add imagecache02 error, insert_data:%s",
str(insert_data))
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="新增cache02地址失败")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg="新增网络区域成功")
def net_area_update(net_area_id):
name = request.values.get('name')
imagecache01 = request.values.get('imagecache01')
imagecache02 = request.values.get('imagecache02')
if not net_area_id or not name or not imagecache01 or not imagecache02:
logging.error('the params is invalid when update net area')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
net_area_data = net_area_s.NetAreaService().get_net_area_info(net_area_id)
if not net_area_data:
logging.error('net area %s is no exist in db when update net area',
net_area_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
if net_area_data['name'] != name:
dc_data = dc_s.DataCenterService().get_datacenter_info(
net_area_data['datacenter_id'])
if not dc_data:
logging.error(
'datacenter %s is no exist in db when update net area',
net_area_data['datacenter_id'])
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 同一环境下机房下的网络区域不能重名
name_exist = net_area_s.check_name_exist_in_same_dc_type(
name, dc_data['dc_type'])
if name_exist:
logging.error(
'name %s in dc_type %s is duplicated when update net area',
name, dc_data['dc_type'])
return json_helper.format_api_resp(code=ErrorCode.DUPLICATED_ERR,
msg='同环境机房下的网络区域名不能重复，请修改网络区域名')
# 两台imagecache不能重复
if imagecache01 == imagecache02:
logging.info('imagecache address duplicated')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="镜像缓存服务器地址重复")
update_data = {
'name': name,
'displayname': name,
'updated_at': get_datetime_str()
}
where_data = {
'id': net_area_id,
}
ret = net_area_s.NetAreaService().update_net_area_info(
update_data, where_data)
if ret < 0:
logging.error("update net area error, update_data:%s, where_data:%s",
str(update_data), str(where_data))
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
imagecache_data = imca_s.ImageCacheService(
).get_imagecache_info_by_net_area_id(net_area_id)
imagecache01_data = imagecache_data[0]
imagecache02_data = imagecache_data[1]
exist_cache_ids = [imagecache01_data['id'], imagecache02_data['id']]
# update imagecache01
where_data = {"id": exist_cache_ids[0]}
update_data = {"imagecache_ip": imagecache01}
ret = imca_s.ImageCacheService().update_imagecache_info(
update_data, where_data)
# update imagecache02
where_data = {"id": exist_cache_ids[1]}
update_data = {"imagecache_ip": imagecache02}
ret = imca_s.ImageCacheService().update_imagecache_info(
update_data, where_data)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def ip_apply():
'''
IP申请
:return:
'''
req_env = request.values.get('env')
req_net_area = request.values.get('net_area')
req_net_name = request.values.get('segment')
cluster_id = request.values.get('cluster_id')
opuser = request.values.get('opUser')
sys_code = request.values.get('sys_code')
# 校验入参是否为空
if not req_env or not req_net_area or not req_net_name:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="环境、网络区域、网段名输入为空")
if not cluster_id or not opuser or not sys_code:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="物理集群、操作用户、系统编码为空输入为空")
# 查询指定环境、网络区域是否有所需网段
ret_segment = segment_service.SegmentService().get_segment_info_bysegment(
req_net_name)
if not ret_segment:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法找到需要申请的网段")
ret_net_area_info = net_area.NetAreaService().get_net_area_info(
ret_segment['net_area_id'])
if not ret_net_area_info:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法找到指定网络区域信息")
ret_datacenter_info = datacenter_service.DataCenterService(
).get_datacenter_info(ret_net_area_info['datacenter_id'])
if not ret_datacenter_info:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法找到指定机房信息")
if req_env not in DataCenterTypeForVishnu.TYPE_DICT:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法找到指定机房类型信息")
if str(DataCenterTypeForVishnu.TYPE_DICT[req_env]
) != ret_datacenter_info['dc_type']:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法找到指定网络区域对应网段信息")
# 获取IP资源，先判断是否有人也在分配IP资源，有则等待1s，时间之后再优化
ip_lock_unused = False
while not ip_lock_unused:
ret_ip_lock_status = ip_l_s.IpLockService().get_ip_lock_info('ip')
if not ret_ip_lock_status:
logging.error('kvm平台分配vip：检查IP时无法获取资源锁状态')
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='检查IP时无法获取资源锁状态')
if ret_ip_lock_status['istraceing'] == IpLockStatus.USED:
time.sleep(1)
else:
ip_lock_unused = True
# 更新ip_lock表istraceing字段为1
ret_ip_lock_used_status, ret_ip_lock_used_datas = __update_ip_lock_used()
if not ret_ip_lock_used_status:
logging.error(ret_ip_lock_used_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=ret_ip_lock_used_datas)
# 获取可用ip
try:
ret_ip_available_status, ret_ip_available = ip_service.get_available_segment_ip(
ret_segment['id'], str(DataCenterTypeForVishnu.TYPE_DICT[req_env]))
except Exception as e:
_msg = 'IP申请ip_apply：获取指定网段可用ip出现异常 : get segment available ip exception when ip apply，err：%s' % e
logging.error(_msg)
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused(
)
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=_msg)
if not ret_ip_available_status:
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused(
)
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="指定网段没有可用ip")
# 标记ip已使用
update_data = {'status': IPStatus.USED}
where_data = {'id': ret_ip_available['id']}
ret_mark_ip = ip_service.IPService().update_ip_info(
update_data, where_data)
if ret_mark_ip <= 0:
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused(
)
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="标记ip为已使用状态失败，请重新申请")
# 更新ip_lock表istraceing字段为0
ret_ip_lock_unused_status, ret_ip_lock_unused_datas = __update_ip_lock_unused(
)
if not ret_ip_lock_unused_status:
logging.error(ret_ip_lock_unused_datas)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=ret_ip_lock_unused_datas)
# 录入vip信息到数据库中
insert_vip_data = {
'ip_id': ret_ip_available['id'],
'cluster_id': cluster_id,
'apply_user_id': opuser,
'sys_code': sys_code,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret_vip = vip_service.VIPService().add_vip_info(insert_vip_data)
if ret_vip.get('row_num') <= 0:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="录入ip信息失败，请联系系统管理员")
ip_msg = {"vip": ret_ip_available['ip_address']}
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, data=ip_msg)
