def instance_add_netcard(instance_id):
'''
kvm平台虚拟机添加网卡接口
:param instance_id:
:return:
'''
# 判断指定虚拟机是否存在
if not instance_id:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR, msg="instance_id为空，添加网卡失败")
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
if not ins_data:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR, msg="无法找到待添加网卡虚拟机")
# 查询指定虚拟机网卡数量，目前不能超过3块
instance_net_card = ins_s.get_net_info_of_instance(instance_id)
if instance_net_card:
if len(instance_net_card) >= INSTANCE_NETCARD_NUMS:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR, msg="虚拟机网卡数量不能超过%s张" % str(INSTANCE_NETCARD_NUMS))
# 往instance_ip表添加记录
mac = randomMAC()
instance_ip_data = {
'instance_id': instance_id,
'mac': mac,
'type': InstanceNicType.NORMAL_NETWORK_NIC,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret_add = ins_ip_s.InstanceIPService().add_instance_ip_info(instance_ip_data)
if ret_add.get('row_num') <= 0:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg="虚拟机网卡创建失败")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg="虚拟机网卡创建成功")
def _create_instance_info(task_id, instance_name, app_info, owner, password,
flavor_id, group_id, vm_host, flavor_info,
image_data, ip_data, vm_disk_gb, mount_point,
instance_system, net_area_id, segment_data, vm_env,
user_id):
uuid = randomUUID()
request_id = ins_s.generate_req_id()
# 往instance表添加记录
logging.info(
'创建VM 步骤10-1：插入instance表 task %s : insert instance table start when create instance',
task_id)
instance_data = {
'uuid': uuid,
'name': instance_name,
'displayname': instance_name,
'description': '',
'status': VMStatus.CREATING,
'typestatus': VMTypeStatus.NORMAL,
'create_source': VMCreateSource.CLOUD_SOURCE,
'isdeleted': '0',
'app_info': app_info,
'owner': owner,
'created_at': get_datetime_str(),
'password': encrypt_helper.encrypt(str(password)), # 密码加密
'request_id': request_id,
'task_id': task_id
}
ret = ins_s.InstanceService().add_instance_info(instance_data)
if ret.get('row_num') <= 0:
logging.error(
'task %s : add instance info error when create instance, insert_data: %s',
task_id, instance_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-1：插入instance表成功 '
'task %s : insert instance table successful when create instance',
task_id)
instance_id = ret.get('last_id')
# 往instance_flavor表添加记录
logging.info(
'创建VM 步骤10-2：插入instance_flavor表 '
'task %s : insert instance_flavor table start when create instance',
task_id)
instance_flavor_data = {
'instance_id': instance_id,
'flavor_id': flavor_id,
'created_at': get_datetime_str()
}
ret1 = ins_f_s.InstanceFlavorService().add_instance_flavor_info(
instance_flavor_data)
if ret1.get('row_num') <= 0:
logging.error(
'task %s : add instance_flavor info error when create instance, insert_data: %s',
task_id, instance_flavor_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-2：插入instance_flavor表成功 '
'task %s : insert instance_flavor table successful when create instance',
task_id)
# 往instance_group表添加记录
logging.info(
'创建VM 步骤10-3：插入instance_group表 task %s : insert instance_group table start when create instance',
task_id)
instance_group_data = {
'instance_id': instance_id,
'group_id': group_id,
'created_at': get_datetime_str()
}
ret2 = ins_g_s.InstanceGroupService().add_instance_group_info(
instance_group_data)
if ret2.get('row_num') <= 0:
logging.error(
'task %s : add instance_group info error when create instance, insert_data: %s',
task_id, instance_group_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-3：插入instance_group表成功 task %s : insert instance_group table successful when create instance',
task_id)
# 往instance_host表添加记录
logging.info(
'创建VM 步骤10-4：插入instance_host表 task %s : insert instance_host table start when create instance',
task_id)
instance_host_data = {
'instance_id': instance_id,
'instance_name': instance_name,
'host_id': vm_host['host_id'],
'host_name': vm_host['name'],
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret3 = ins_h_s.InstanceHostService().add_instance_host_info(
instance_host_data)
if ret3.get('row_num') <= 0:
logging.error(
'task %s : add instance_host info error when create instance, insert_data: %s',
task_id, instance_host_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-4：插入instance_host表成功 '
'task %s : insert instance_host table successful when create instance',
task_id)
# host预分配资源
logging.info(
'创建VM 步骤10-5：host预分配资源 task %s : pre allocate host resource start when create instance',
task_id)
ret4 = host_s.pre_allocate_host_resource(vm_host['host_id'],
flavor_info['vcpu'],
flavor_info['memory_mb'],
flavor_info['root_disk_gb'])
if ret4 != 1:
logging.error(
'task %s : pre allocate host resource to db error when create instance',
task_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-5：host预分配资源成功 '
'task %s : pre allocate host resource successful when create instance',
task_id)
# 往instance_image表添加记录
logging.info(
'创建VM 步骤10-6：插入instance_image表 task %s : insert instance_image table start when create instance',
task_id)
for _image in image_data:
instance_image_data = {
'instance_id': instance_id,
'image_id': _image['id'],
'created_at': get_datetime_str()
}
ret5 = ins_img_s.InstanceImageService().add_instance_image_info(
instance_image_data)
if ret5.get('row_num') <= 0:
logging.error(
'task %s : add instance_image info error when create instance, insert_data: %s',
task_id, instance_image_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-6：插入instance_image表成功 '
'task %s : insert instance_image table successful when create instance',
task_id)
# 往instance_ip表添加记录
logging.info(
'创建VM 步骤10-7：插入instance_ip表 '
'task %s : insert instance_ip table start when create instance',
task_id)
mac = randomMAC()
data_ip_address = ip_data['ip_address']
instance_ip_data = {
'instance_id': instance_id,
'ip_id': ip_data['id'],
'mac': mac,
'type': InstanceNicType.MAIN_NETWORK_NIC,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret6 = ins_ip_s.InstanceIPService().add_instance_ip_info(instance_ip_data)
if ret6.get('row_num') <= 0:
logging.error(
'task %s : add instance_ip info error when create instance, insert_data: %s',
task_id, instance_ip_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-7：插入instance_ip表成功 '
'task %s : insert instance_ip table successful when create instance',
task_id)
# 标识该IP为已使用
logging.info(
'创建VM 步骤10-8：设置IP为已使用 task %s : set ip used start when create instance',
task_id)
update_data = {'status': IPStatus.USED}
where_data = {'id': ip_data['id']}
ret7 = ip_service.IPService().update_ip_info(update_data, where_data)
if ret7 <= 0:
logging.info(
'task %s : update ip info error when create instance, update_data: %s, where_data: %s',
task_id, update_data, where_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'创建VM 步骤10-8：设置IP为已使用成功 task %s : set ip used successful when create instance',
task_id)
# 拼装消息需要的镜像信息
logging.info(
'创建VM 步骤10-9：拼装所需的镜像信息 '
'task %s : piece together need image info start when create instance',
task_id)
image_list = []
# 数据盘数量
data_image_num = 0
for _image in image_data:
_image_type = _image['type']
_info = {
"disk_format": _image['format'],
"url": _image['url'],
# "md5sum": _image['md5'],
"image_size_gb": _image['size_gb'] # 镜像预分配大小
}
# 系统盘
if _image_type == ImageType.SYSTEMDISK:
_disk_name = instance_name + '.img'
_info['image_dir_path'] = '/app/image/' + uuid + '/' + _disk_name
_info['disk_name'] = _disk_name
_info['disk_size_gb'] = None
_info['dev_name'] = 'vda'
# 如果只有一块盘且为系统盘，则预先分配一块数据盘的数据存入instance_disk表
if len(image_data) == 1:
logging.info(
'task %s : pre insert instance_disk table that has only one system disk start when create '
'instance', task_id)
instance_disk_data = {
'instance_id': instance_id,
'size_gb': vm_disk_gb,
'mount_point': mount_point,
'dev_name': 'vdb',
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret9 = ins_d_s.InstanceDiskService().add_instance_disk_info(
instance_disk_data)
if ret9.get('row_num') <= 0:
logging.info(
'task %s : pre add instance_disk info that has only one system disk error when create '
'instance, insert_data: %s', task_id,
instance_disk_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'task %s : pre insert instance_disk table that has only one system disk successful when '
'create instance', task_id)
else:
# 数据盘
_disk_name = instance_name + '.disk' + str(data_image_num + 1)
_disk_dev_name = _get_vd_map(data_image_num)
_info['image_dir_path'] = '/app/image/' + uuid + '/' + _disk_name
_info['disk_name'] = _disk_name
_info['disk_size_gb'] = vm_disk_gb
_info['dev_name'] = _disk_dev_name
data_image_num += 1
# 往instance_disk表添加记录
logging.info(
'task %s : insert instance_disk table start when create instance',
task_id)
instance_disk_data = {
'instance_id': instance_id,
'size_gb': vm_disk_gb,
'mount_point': mount_point,
'dev_name': _disk_dev_name,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret8 = ins_d_s.InstanceDiskService().add_instance_disk_info(
instance_disk_data)
if ret8.get('row_num') <= 0:
logging.info(
'task %s : add instance_disk info error when create instance, insert_data: %s',
task_id, instance_disk_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
logging.info(
'task %s : insert instance_disk table successful when create instance',
task_id)
image_list.append(_info)
logging.info(
'创建VM 步骤10-9：拼装所需的镜像信息成功 '
'task %s : piece together need image info successful when create instance',
task_id)
# 发送异步消息到队列
logging.info(
'创建VM 步骤10-10：发送异步消息给队列 '
'task %s : send kafka message start when create instance', task_id)
data = {
"routing_key": "INSTANCE.CREATE",
"send_time": get_datetime_str(),
"data": {
"task_id":
task_id,
"request_id":
request_id,
"host_ip":
vm_host['ipaddress'],
"uuid":
uuid,
"hostname":
instance_name, # 实例名
"memory_mb":
flavor_info['memory_mb'],
"vcpu":
flavor_info['vcpu'],
"ostype":
instance_system,
"user_id":
user_id,
"disks":
image_list,
"disk_size":
vm_disk_gb,
"image_name":
_image['url'].split('/')[-1],
"net_area_id":
net_area_id,
"networks": [{
"net_card_name": "br_bond0." + segment_data['vlan'],
"ip": data_ip_address,
"netmask": segment_data['netmask'],
"dns1": segment_data['dns1'],
"dns2": segment_data['dns2'],
"mac": mac,
"gateway": segment_data['gateway_ip'],
"env": vm_env # SIT STG PRD DR
}]
}
}
ret_kafka = send_async_msg(KAFKA_TOPIC_NAME, data)
def _task_esx_intodb(task):
# 获取vm入参
vmname = task['vm_name']
vmip = task['vm_ip']
flavor_id = task['flavor_id']
vm_ostype = task['vm_ostype']
vm_app_info = task['vm_app_info']
vm_owner = task['vm_owner']
vm_segment = task['vm_segment']
vm_group_id = task['group_id']
dest_host = task['dest_host']
vmhost = ho_s.HostService().get_host_info_by_hostip(dest_host)
ret_4 = ho_s.pre_allocate_host_resource(vmhost['id'], task['vm_cpu'],
task['vm_mem_mb'], 50)
if ret_4 != 1:
logging.error('资源预分配失败')
message = '资源预分配失败'
return False, message
# 获取并录入IP信息
vm_segment = seg_s.SegmentService().get_segment_info_bysegment(vm_segment)
if vm_segment is None:
message = '网段信息有误，无法进行v2v操作'
return False, message
else:
segment_id = vm_segment['id']
vm_netmask = vm_segment['netmask']
vm_gateway = vm_segment['gateway_ip']
vm_dns1 = vm_segment['dns1']
vm_dns2 = vm_segment['dns2']
vmvlan = vm_segment['vlan']
ip_data = ip_s.IPService().get_ip_info_by_ipaddress(vmip)
if ip_data is None:
ip_data = {
'ip_address': vmip,
'segment_id': segment_id,
'netmask': vm_netmask,
'vlan': vmvlan,
'gateway_ip': vm_gateway,
'dns1': vm_dns1,
'dns2': vm_dns2,
'created_at': get_datetime_str(),
'status': '1'
}
ret = ip_s.IPService().add_ip_info(ip_data)
if ret.get('row_num') <= 0:
logging.info(
'add ip info error when create v2v task, insert_data: %s',
ip_data)
message = "录入IP信息失败"
return False, message
else:
ip_id = ret.get('last_id')
else:
ip_data_status = ip_data['status']
vmvlan = ip_data['vlan']
if ip_data_status != '0':
message = "IP与现有环境冲突,无法进行v2v操作"
return False, message
else:
ip_id = ip_data['id']
where_data = {'id': ip_id}
updata_data = {'status': '1', 'updated_at': get_datetime_str()}
ret1 = ip_s.IPService().update_ip_info(updata_data, where_data)
if not ret1:
logging.info(
'update ip info error when create v2v task, update_data: %s',
updata_data)
message = "更新IP状态失败"
return False, message
# 生成request_id
request_id = v2v_op.generate_req_id()
# 生成vm的uuid和mac
vmuuid = randomUUID()
vmmac = randomMAC()
# 信息入instance相关库表
instance_tag, instance_info = _instance_db_info(
vmuuid, vmname, vm_app_info, vm_owner, flavor_id, vm_group_id,
dest_host, vmmac, task['vm_disk'], ip_id, vm_ostype, request_id,
task['vm_os_version'])
if not instance_tag:
message = instance_info
return False, message
# 将步骤信息存入instance_action表
v2v_cd_d1 = {
'action': esx_v2vActions.CREATE_DEST_DIR,
'request_id': request_id,
'message': 'start',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cd_d1)
v2v_cr_pl = {
'action': esx_v2vActions.CREATE_STOR_POOL,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cr_pl)
v2v_cp_fl = {
'action': esx_v2vActions.COPY_FILE_TO_LOCAL,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cp_fl)
v2v_file = {
'action': esx_v2vActions.VIRT_V2V_FILES,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_file)
v2v_del_tmp = {
'action': esx_v2vActions.DELETE_TMP_FILE,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_del_tmp)
v2v_sysdisk_std = {
'action': esx_v2vActions.VM_SYS_DISK_STD,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_sysdisk_std)
v2v_datadisk_std = {
'action': esx_v2vActions.VM_DATA_DISK_STD,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_datadisk_std)
v2v_def_1 = {
'action': esx_v2vActions.VM_DEFINE1,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_def_1)
v2v_star_1 = {
'action': esx_v2vActions.VM_START1,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_star_1)
if vm_ostype == "Windows":
v2v_att_disk = {
'action': esx_v2vActions.ATTACH_DISK,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_att_disk)
v2v_win_std = {
'action': esx_v2vActions.WINDOWS_STD,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_win_std)
v2v_vm_def2 = {
'action': esx_v2vActions.WINDOWS_DISK_CH,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vm_def2)
v2v_vm_star2 = {
'action': esx_v2vActions.VM_START2,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vm_star2)
# 将v2v信息存入v2v_task表
v2v_data = {
'source': VMCreateSource.ESX,
'request_id': request_id,
'destory': '0',
'start_time': get_datetime_str(),
'status': 0,
'vm_ip': vmip,
'vm_name': vmname,
'vmvlan': vmvlan,
'flavor_id': flavor_id,
'cloud_area': task['esx_env'],
'vm_ostype': vm_ostype,
'vm_app_info': vm_app_info,
'vm_owner': vm_owner,
'vm_group_id': vm_group_id,
'user_id': task['user_id'],
'vm_mac': vmmac,
'vm_uuid': vmuuid,
'cancel': '0',
'dest_dir': '/app/image/' + vmuuid,
'on_task': '0',
'dest_host': dest_host,
'esx_ip': task['esx_ip'],
'esx_passwd': task['esx_passwd'],
'vmware_vm': task['vmware_vm'],
'step_done': esx_v2vActions.BEGIN
}
v2v_insert = v2v_op.v2vTaskService().add_v2v_task_info(v2v_data)
if v2v_insert.get('row_num') <= 0:
logging.info('insert info to v2v_task failed! %s', v2v_data)
message = '信息入库失败'
return False, message
message = '信息已添加至任务队列'
return True, message
def v2v_esx_intodb(hostpool_id):
'''
v2v_esx
:param hostpool_id:
:return:
'''
#获取vm入库信息
vmname = request.values.get('vm_name')
vmip = request.values.get('vm_ip')
flavor_id = request.values.get('flavor_id')
vm_ostype = request.values.get('vm_ostype')
vm_app_info = request.values.get('vm_app_info')
vm_owner = request.values.get('vm_owner')
vm_group_id = request.values.get('vm_group_id')
user_id = request.values.get('user_id')
vm_segment = request.values.get('segment')
vm_osver = request.values.get('vm_osver')
vm_disk = request.values.get('vm_disk')
esx_env = request.values.get('esx_env')
esx_ip = request.values.get('esx_ip')
esx_passwd1 = request.values.get('esx_passwd')
vmware_vm = request.values.get('vmware_vm')
# 入参完全性判断
if not vmname or not vmip or not flavor_id or not vm_ostype or not vm_app_info \
or not vm_osver or not vm_disk or not vm_owner or not vm_group_id or not user_id or not vm_segment or not esx_passwd1:
logging.info('params are invalid or missing')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='入参缺失')
else:
esx_passwd = base64.b64decode(esx_passwd1)
powertag, msg_power = vm_powerState(esx_ip, esx_passwd, vmware_vm)
if not powertag:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=msg_power)
# 获取flavor信息
flavor_info = flavor_service.FlavorService().get_flavor_info(flavor_id)
if not flavor_info:
logging.info('id: %s flavor info not in db when create instance',
flavor_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='实例规格数据有误，无法进行v2v')
vmcpu = flavor_info['vcpu']
vmmem = flavor_info['memory_mb']
data_disk = int(vm_disk)
# 获取可用目标host
host_code, host_data, host_msg = cal_host(hostpool_id, vmcpu, vmmem,
data_disk, vm_group_id)
if host_code < 0:
return json_helper.format_api_resp(code=host_code, msg=host_msg)
else:
host = host_data
vmhost = ho_s.HostService().get_host_info_by_hostip(host)
ret_4 = ho_s.pre_allocate_host_resource(vmhost['id'], vmcpu, vmmem, 50)
if ret_4 != 1:
logging.error('资源预分配失败')
message = '资源预分频失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
# 获取并录入IP信息
vm_segment = seg_s.SegmentService().get_segment_info_bysegment(
vm_segment)
if vm_segment == None:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='网段信息有误，无法进行v2v')
else:
segment_id = vm_segment['id']
vm_netmask = vm_segment['netmask']
vm_gateway = vm_segment['gateway_ip']
vm_dns1 = vm_segment['dns1']
vm_dns2 = vm_segment['dns2']
vmvlan = vm_segment['vlan']
ip_data = ip_s.IPService().get_ip_info_by_ipaddress(vmip)
if ip_data == None:
ip_data = {
'ip_address': vmip,
'segment_id': segment_id,
'netmask': vm_netmask,
'vlan': vmvlan,
'gateway_ip': vm_gateway,
'dns1': vm_dns1,
'dns2': vm_dns2,
'created_at': get_datetime_str(),
'status': '1'
}
ret = ip_s.IPService().add_ip_info(ip_data)
if ret.get('row_num') <= 0:
logging.info(
'add ip info error when create v2v task, insert_data: %s',
ip_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="录入IP信息失败")
else:
ip_id = ret.get('last_id')
else:
ip_data_status = ip_data['status']
vmvlan = ip_data['vlan']
if ip_data_status != '0':
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="IP与现有环境冲突,无法进行v2v")
else:
ip_id = ip_data['id']
where_data = {'id': ip_id}
updata_data = {
'status': '1',
'updated_at': get_datetime_str()
}
ret1 = ip_s.IPService().update_ip_info(
updata_data, where_data)
if not ret1:
logging.info(
'update ip info error when create v2v task, update_data: %s',
updata_data)
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR, msg="更新IP状态失败")
# 生成request_id
request_Id = v2v_op.generate_req_id()
# 生成vm的uuid和mac
vmuuid = randomUUID()
vmmac = randomMAC()
if not vm_osver:
vm_osver = "unknown"
# 信息入instance相关库表
instance_info = instance_db_info(vmuuid, vmname, vm_app_info, vm_owner,
flavor_id, vm_group_id, host, vmmac,
data_disk, ip_id, vm_ostype,
request_Id, vm_osver)
if instance_info < 0:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='信息入库失败')
# 将步骤信息存入instance_action表
v2v_cd_d1 = {
'action': esx_v2vActions.CREATE_DEST_DIR,
'request_id': request_Id,
'message': 'start',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cd_d1)
v2v_cr_pl = {
'action': esx_v2vActions.CREATE_STOR_POOL,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cr_pl)
v2v_cp_fl = {
'action': esx_v2vActions.COPY_FILE_TO_LOCAL,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cp_fl)
v2v_file = {
'action': esx_v2vActions.VIRT_V2V_FILES,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_file)
v2v_del_tmp = {
'action': esx_v2vActions.DELETE_TMP_FILE,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_del_tmp)
v2v_sysdisk_std = {
'action': esx_v2vActions.VM_SYS_DISK_STD,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_sysdisk_std)
v2v_datadisk_std = {
'action': esx_v2vActions.VM_DATA_DISK_STD,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_datadisk_std)
v2v_def_1 = {
'action': esx_v2vActions.VM_DEFINE1,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_def_1)
v2v_star_1 = {
'action': esx_v2vActions.VM_START1,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_star_1)
if vm_ostype == "Windows":
v2v_att_disk = {
'action': esx_v2vActions.ATTACH_DISK,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_att_disk)
v2v_win_std = {
'action': esx_v2vActions.WINDOWS_STD,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_win_std)
v2v_vm_def2 = {
'action': esx_v2vActions.WINDOWS_DISK_CH,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vm_def2)
v2v_vm_star2 = {
'action': esx_v2vActions.VM_START2,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vm_star2)
message = '信息已添加至任务队列,等待执行'
# 将v2v信息存入v2v_task表
v2v_data = {
'source': VMCreateSource.ESX,
'request_id': request_Id,
'destory': '0',
'start_time': get_datetime_str(),
'status': 0,
'vm_ip': vmip,
'vm_name': vmname,
'vmvlan': vmvlan,
'flavor_id': flavor_id,
'cloud_area': esx_env,
'vm_ostype': vm_ostype,
'vm_app_info': vm_app_info,
'vm_owner': vm_owner,
'vm_group_id': vm_group_id,
'user_id': user_id,
'vm_mac': vmmac,
'vm_uuid': vmuuid,
'cancel': '0',
'dest_dir': '/app/image/' + vmuuid,
'on_task': '0',
'dest_host': host,
'esx_ip': esx_ip,
'esx_passwd': esx_passwd,
'vmware_vm': vmware_vm,
'step_done': esx_v2vActions.BEGIN
}
v2v_insert = v2v_op.v2vTaskService().add_v2v_task_info(v2v_data)
if v2v_insert.get('row_num') <= 0:
logging.info('insert info to v2v_task failed! %s', v2v_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='信息入库失败')
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg=message)
def _task_into_db(task):
# 入参赋值
vmname = task['vm_name']
vmip = task['vm_ip']
flavor_id = task['flavor_id']
cloudarea = task['cloud_area']
vm_ostype = task['vm_ostype']
vm_app_info = task['vm_app_info']
vm_owner = task['vm_owner']
vm_group_id = task['group_id']
user_id = task['user_id']
vm_segment = task['segment']
vm_disk = task['vm_disk']
vm_osver = task['vm_osver']
host = task['dest_host']
# 入参完全性判断
if not vmname or not vmip or not flavor_id or not cloudarea or not vm_ostype \
or not vm_app_info or not vm_owner or not vm_group_id or not user_id or not vm_segment:
logging.info('params are invalid or missing')
message = '入参缺失'
return False, message
else:
# 获取flavor信息
flavor_info = flavor_s.FlavorService().get_flavor_info(flavor_id)
if not flavor_info:
logging.info('id: %s flavor info not in db when create instance',
flavor_id)
message = '实例规格数据有误，无法进行v2v'
return False, message
vmcpu = flavor_info['vcpu']
vmmem = flavor_info['memory_mb']
vmhost = ho_s.HostService().get_host_info_by_hostip(host)
ret_4 = ho_s.pre_allocate_host_resource(vmhost['id'], vmcpu, vmmem, 50)
if ret_4 != 1:
logging.error('资源预分配失败')
message = '资源预分频失败'
return False, message
# 获取并录入IP信息
vm_segment = segment_s.SegmentService().get_segment_info_bysegment(
vm_segment)
if vm_segment is None:
message = '网段信息有误，无法进行v2v'
return False, message
else:
segment_id = vm_segment['id']
vm_netmask = vm_segment['netmask']
vm_gateway = vm_segment['gateway_ip']
vm_dns1 = vm_segment['dns1']
vm_dns2 = vm_segment['dns2']
vmvlan = vm_segment['vlan']
ip_data = ip_s.IPService().get_ip_info_by_ipaddress(vmip)
if ip_data is None:
ip_data = {
'ip_address': vmip,
'segment_id': segment_id,
'netmask': vm_netmask,
'vlan': vmvlan,
'gateway_ip': vm_gateway,
'dns1': vm_dns1,
'dns2': vm_dns2,
'created_at': get_datetime_str(),
'status': '1'
}
ret = ip_s.IPService().add_ip_info(ip_data)
if ret.get('row_num') <= 0:
logging.info(
'add ip info error when create v2v task, insert_data: %s',
ip_data)
message = "录入IP信息失败"
return False, message
else:
ip_id = ret.get('last_id')
else:
ip_data_status = ip_data['status']
vmvlan = ip_data['vlan']
if ip_data_status != '0':
message = "IP与现有环境冲突,无法进行v2v"
return False, message
else:
ip_id = ip_data['id']
where_data = {'id': ip_id}
updata_data = {
'status': '1',
'updated_at': get_datetime_str()
}
ret1 = ip_s.IPService().update_ip_info(
updata_data, where_data)
if not ret1:
logging.info(
'update ip info error when create v2v task, update_data: %s',
updata_data)
message = "更新IP状态失败"
return False, message
# 生成request_id
request_id = v2v_op.generate_req_id()
# 生成vm的uuid和mac
vmuuid = randomUUID()
vmmac = randomMAC()
# 信息入instance相关库表
instance_tag, instance_info = _instance_db_info(
vmuuid, vmname, vm_app_info, vm_owner, flavor_id, vm_group_id,
host, vmmac, vm_disk, ip_id, vm_ostype, request_id, vm_osver)
if not instance_tag:
message = instance_info
return False, message
# 将步骤信息存入instance_action表
# 将createdir信息存入instance_action表
v2v_cd_d1 = {
'action': v2vActions.CREATE_DEST_DIR,
'request_id': request_id,
'message': 'start',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cd_d1)
# 将getfile信息存入instance_action表
v2v_gf_d1 = {
'action': v2vActions.GET_VM_FILE,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_gf_d1)
# 将copy disk信息存入instance_action表
v2v_cpd_d1 = {
'action': v2vActions.COPY_VM_DISK,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cpd_d1)
# 将copy xml信息存入instance_action表
v2v_cpx_d1 = {
'action': v2vActions.COPY_VM_XML,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_cpx_d1)
# 将创建存储池信息存入instance_action表
v2v_csp_d1 = {
'action': v2vActions.CREATE_STOR_POOL,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_csp_d1)
# 将vm标准化信息存入instance_action表
v2v_vmd_d1 = {
'action': v2vActions.VM_STANDARDLIZE,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_vmd_d1)
# 将vm注册信息存入instance_action表
v2v_vmdef_d1 = {
'action': v2vActions.VM_DEFINE,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_vmdef_d1)
# 将IP注入信息存入instance_action表
v2v_vmipj_d1 = {
'action': v2vActions.IP_INJECT,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(v2v_vmipj_d1)
# 将vm开机信息存入instance_action表
v2v_vmstar_d1 = {
'action': v2vActions.VM_START,
'request_id': request_id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vmstar_d1)
message = '信息已添加至任务队列,等待执行'
# 将v2v信息存入v2v_task表
v2v_data = {
'request_id': request_id,
'destory': '0',
'start_time': get_datetime_str(),
'status': 0,
'vm_ip': vmip,
'vm_name': vmname,
'vmvlan': vmvlan,
'flavor_id': flavor_id,
'cloud_area': cloudarea,
'vm_ostype': vm_ostype,
'vm_app_info': vm_app_info,
'vm_owner': vm_owner,
'vm_group_id': vm_group_id,
'user_id': user_id,
'vm_mac': vmmac,
'vm_uuid': vmuuid,
'cancel': '0',
'dest_dir': '/app/image/' + vmuuid,
'on_task': '0',
'port': '10000',
'source': VMCreateSource.OPENSTACK
}
v2v_insert = v2v_op.v2vTaskService().add_v2v_task_info(v2v_data)
if v2v_insert.get('row_num') <= 0:
logging.info('insert info to v2v_task failed! %s', v2v_data)
message = '信息入库失败'
return False, message
# 将目标kvmhost存入信息表
v2v_op.update_v2v_desthost(request_id, host)
v2v_op.update_v2v_step(request_id, v2vActions.BEGIN)
return True, message
def v2v_openstack_intodb(hostpool_id):
'''
v2v_openstack
:param hostpool_id:
:return:
'''
# 判断是否为重试操作
retry = request.values.get('retry')
# 如果非重试进行以下步骤
if retry != '1':
# 入参赋值
vmname = request.values.get('vm_name').strip()
vmip = request.values.get('vm_ip').strip()
flavor_id = request.values.get('flavor_id').strip()
cloudarea = request.values.get('cloud_area').strip()
vm_ostype = request.values.get('vm_ostype').strip()
vm_app_info = request.values.get('vm_app_info').strip()
vm_owner = request.values.get('vm_owner').strip()
vm_group_id = request.values.get('group_id').strip()
user_id = request.values.get('user_id').strip()
vm_segment = request.values.get('segment').strip()
# 入参完全性判断
if not vmname or not vmip or not flavor_id or not cloudarea or not vm_ostype \
or not vm_app_info or not vm_owner or not vm_group_id or not user_id or not vm_segment:
logging.info('params are invalid or missing')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='入参缺失')
else:
# 获取flavor信息
flavor_info = flavor_service.FlavorService().get_flavor_info(
flavor_id)
if not flavor_info:
logging.info(
'id: %s flavor info not in db when create instance',
flavor_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='实例规格数据有误，无法进行v2v')
vmcpu = flavor_info['vcpu']
vmmem = flavor_info['memory_mb']
# 获取对应openstack环境的管理节点及ssh账户信息
if cloudarea == "SIT":
ctr_host = '10.202.83.12'
ctr_pass = decrypt(OPENSTACK_SIT_PASS)
elif cloudarea == "DEV":
ctr_host = "10.202.123.4"
ctr_pass = decrypt(OPENSTACK_DEV_PASS)
else:
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR, msg='openstack环境参数错误，无法进行v2v操作')
#判断vm信息是否输入错误
vmexist = vm_exist(vmip, ctr_host, ctr_pass)
if vmexist == False:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='获取vm信息失败')
#获取OS版本失败
osstat, verdata = get_vm_version(ctr_host, ctr_pass, vm_ostype,
vmip)
if osstat == False:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='获取vmOS版本失败')
else:
ver_data = verdata
# 获取待迁移vm磁盘大小
vdiskdata = vm_disk_size(vmip, cloudarea, ctr_host, ctr_pass)
if vdiskdata == False:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='获取vm磁盘信息失败')
vdisk = vdiskdata
data_disk = vdisk - 80
# 判断待转化vm是否关机
vmshutdown = vm_stat(vmip, ctr_host, ctr_pass)
if vmshutdown == False:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='待转化vm未关机')
# 获取可用目标host
host_code, host_data, host_msg = cal_host(hostpool_id, vmcpu,
vmmem, data_disk,
vm_group_id)
if host_code < 0:
return json_helper.format_api_resp(code=host_code,
msg=host_msg)
else:
host = host_data
vmhost = ho_s.HostService().get_host_info_by_hostip(host)
ret_4 = ho_s.pre_allocate_host_resource(vmhost['id'], vmcpu, vmmem,
50)
if ret_4 != 1:
logging.error('资源预分配失败')
message = '资源预分频失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
# 获取并录入IP信息
vm_segment = seg_s.SegmentService().get_segment_info_bysegment(
vm_segment)
if vm_segment == None:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='网段信息有误，无法进行v2v')
else:
segment_id = vm_segment['id']
vm_netmask = vm_segment['netmask']
vm_gateway = vm_segment['gateway_ip']
vm_dns1 = vm_segment['dns1']
vm_dns2 = vm_segment['dns2']
vmvlan = vm_segment['vlan']
ip_data = ip_s.IPService().get_ip_info_by_ipaddress(vmip)
if ip_data == None:
ip_data = {
'ip_address': vmip,
'segment_id': segment_id,
'netmask': vm_netmask,
'vlan': vmvlan,
'gateway_ip': vm_gateway,
'dns1': vm_dns1,
'dns2': vm_dns2,
'created_at': get_datetime_str(),
'status': '1'
}
ret = ip_s.IPService().add_ip_info(ip_data)
if ret.get('row_num') <= 0:
logging.info(
'add ip info error when create v2v task, insert_data: %s',
ip_data)
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR, msg="录入IP信息失败")
else:
ip_id = ret.get('last_id')
else:
ip_data_status = ip_data['status']
vmvlan = ip_data['vlan']
if ip_data_status != '0':
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR, msg="IP与现有环境冲突,无法进行v2v")
else:
ip_id = ip_data['id']
where_data = {'id': ip_id}
updata_data = {
'status': '1',
'updated_at': get_datetime_str()
}
ret1 = ip_s.IPService().update_ip_info(
updata_data, where_data)
if not ret1:
logging.info(
'update ip info error when create v2v task, update_data: %s',
updata_data)
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR, msg="更新IP状态失败")
# 生成request_id
request_Id = v2v_op.generate_req_id()
# 生成vm的uuid和mac
vmuuid = randomUUID()
vmmac = randomMAC()
# 信息入instance相关库表
instance_info = instance_db_info(vmuuid, vmname, vm_app_info,
vm_owner, flavor_id, vm_group_id,
host, vmmac, data_disk, ip_id,
vm_ostype, request_Id, ver_data)
if instance_info < 0:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='信息入库失败')
# 将步骤信息存入instance_action表
# 将createdir信息存入instance_action表
v2v_cd_d1 = {
'action': v2vActions.CREATE_DEST_DIR,
'request_id': request_Id,
'message': 'start',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_cd_d1)
# 将getfile信息存入instance_action表
v2v_gf_d1 = {
'action': v2vActions.GET_VM_FILE,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_gf_d1)
# 将copy disk信息存入instance_action表
v2v_cpd_d1 = {
'action': v2vActions.COPY_VM_DISK,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_cpd_d1)
# 将copy xml信息存入instance_action表
v2v_cpx_d1 = {
'action': v2vActions.COPY_VM_XML,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_cpx_d1)
# 将创建存储池信息存入instance_action表
v2v_csp_d1 = {
'action': v2vActions.CREATE_STOR_POOL,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_csp_d1)
# 将vm标准化信息存入instance_action表
v2v_vmd_d1 = {
'action': v2vActions.VM_STANDARDLIZE,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vmd_d1)
# 将vm注册信息存入instance_action表
v2v_vmdef_d1 = {
'action': v2vActions.VM_DEFINE,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vmdef_d1)
# 将IP注入信息存入instance_action表
v2v_vmipj_d1 = {
'action': v2vActions.IP_INJECT,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vmipj_d1)
# 将vm开机信息存入instance_action表
v2v_vmstar_d1 = {
'action': v2vActions.VM_START,
'request_id': request_Id,
'message': 'other',
'start_time': get_datetime_str()
}
in_a_s.InstanceActionsServices().add_instance_action_info(
v2v_vmstar_d1)
message = '信息已添加至任务队列,等待执行'
# 将v2v信息存入v2v_task表
v2v_data = {
'request_id': request_Id,
'destory': '0',
'start_time': get_datetime_str(),
'status': 0,
'vm_ip': vmip,
'vm_name': vmname,
'vmvlan': vmvlan,
'flavor_id': flavor_id,
'cloud_area': cloudarea,
'vm_ostype': vm_ostype,
'vm_app_info': vm_app_info,
'vm_owner': vm_owner,
'vm_group_id': vm_group_id,
'user_id': user_id,
'vm_mac': vmmac,
'vm_uuid': vmuuid,
'cancel': '0',
'dest_dir': '/app/image/' + vmuuid,
'on_task': '0',
'port': '10000',
'source': VMCreateSource.OPENSTACK
}
v2v_insert = v2v_op.v2vTaskService().add_v2v_task_info(v2v_data)
if v2v_insert.get('row_num') <= 0:
logging.info('insert info to v2v_task failed! %s', v2v_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='信息入库失败')
# 将目标kvmhost存入信息表
v2v_op.update_v2v_desthost(request_Id, host)
v2v_op.update_v2v_step(request_Id, v2vActions.BEGIN)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg=message)
def instance_add_netcard_from_other_platform():
'''
kvm平台虚拟机添加网卡外部接口
入参说明：
{
"instanceMainIp": "虚拟机主网ip列表"
"apiOrigin": "",
"netCardType": ""
}
:return:
'''
_init_log('instance_add_netcard_from_other_platform')
logging.info(request.data)
logging.info(request.values)
logging.info(request.form)
req_json = request.data
req_data = json_helper.loads(req_json)
instance_ip_list = req_data["instanceMainIp"]
req_origin = req_data["apiOrigin"]
netcard_type = req_data["netCardType"]
# 判断需要配置网卡所有虚拟机是否存在
if not instance_ip_list or not req_origin or not netcard_type:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='入参有空值，请检查')
_ip_datas_list = []
instance_data_list = []
env_list = []
dc_list = []
net_area_list = []
ip_str = ""
# 判断ip列表中是否有不存在于kvm平台的
for _ip in instance_ip_list:
_instance_info = ip_s.get_instance_info_by_ip(_ip['ip'])
if not _instance_info:
ip_str += _ip['ip'] + " "
else:
_instance_params = {
"instance_ip": _ip['ip'],
"instance_uuid": _instance_info['instance_uuid'],
"instance_id": _instance_info['instance_id'],
"instance_name": _instance_info['instance_name'],
"host_ip": _instance_info['host_ip'],
"env": _instance_info['env'],
"net_area": _instance_info['net_area_name'],
"dc_name": _instance_info['datacenter_name'],
}
instance_data_list.append(_instance_params)
env_list.append(_instance_info['env'])
dc_list.append(_instance_info['datacenter_name'])
net_area_list.append(_instance_info['net_area_name'])
if ip_str:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='ip:%s无法在kvm平台中找到' %
ip_str)
if len(set(env_list)) > 1:
return json_helper.format_api_resp_msg(
code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='需要配置网卡的虚拟机属于不同环境，不允许同时配置')
if len(set(dc_list)) > 1:
return json_helper.format_api_resp_msg(
code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='需要配置网卡的虚拟机属于不同机房，不允许同时配置')
if len(set(net_area_list)) > 1:
return json_helper.format_api_resp_msg(
code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='需要配置网卡的虚拟机属于不同网络区域，不允许同时配置')
instance_str = ""
instance_data_filter_list = []
# 查询指定虚拟机网卡数量，目前不能超过3块，同一类型网卡只能有一块
for _instance in instance_data_list:
instance_same_netcard_type_str = ""
instance_net_card = instance_s.get_net_info_of_instance(
_instance['instance_id'])
if instance_net_card:
for _net_card in instance_net_card:
if _net_card['segment_type'] == netcard_type:
instance_same_netcard_type_str += _instance[
'instance_ip'] + " "
_ip_datas = {
"instanceIp": _instance['instance_ip'],
"nasIp": _net_card['ip_address']
}
_ip_datas_list.append(_ip_datas)
if not instance_same_netcard_type_str:
instance_data_filter_list.append(_instance)
if len(instance_net_card) >= INSTANCE_NETCARD_NUMS:
instance_str += _instance['instance_ip'] + " "
if instance_str:
return json_helper.format_api_resp_msg(
code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='虚拟机:%s网卡数量不能大于%s' % (ip_str, str(INSTANCE_NETCARD_NUMS)))
# if instance_same_netcar_type_str:
# return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR, job_status=VsJobStatus.FAILED,
# detail='虚拟机:%s已配置相同类型网卡，不可重复申请' % ip_str)
if len(instance_data_filter_list) == 0:
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS,
job_status=VsJobStatus.SUCCEED,
detail=_ip_datas_list)
# 判断虚拟机虚拟机是否开机中
instance_unstarting_str = ""
for _instance in instance_data_filter_list:
vm_status = vmManager.libvirt_instance_status(
_instance['host_ip'], _instance['instance_name'])
# 虚拟机开机状态才可以做网卡配置
if vm_status != VMLibvirtStatus.STARTUP:
instance_unstarting_str += _instance['instance_ip'] + " "
if instance_unstarting_str:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='虚拟机:%s非运行中状态，无法添加网卡' %
ip_str)
# 识别需要创建的网卡类型并分配ip
net_type = [
NetCardType.INTERNAL, NetCardType.INTERNEL_TELECOM,
NetCardType.INTERNEL_UNICOM, NetCardType.INTERNAL_IMAGE,
NetCardType.INTERNAL_NAS
]
if netcard_type not in net_type:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail='KVM虚拟机没有网卡类型:%s ' %
netcard_type)
# 获取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('外部接口新增网卡分配ip：检查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:
ret_segment_datas = segment_s.get_segments_data_by_type(
net_area_list[0], dc_list[0], str(env_list[0]), str(netcard_type))
if not ret_segment_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='虚拟机所在网络区域没有指定网卡类型可用网段')
# 获取可用ip并标记为已使用
ret_ip_status, ret_ip_data, ret_ip_msg = __check_ip_resource(
ret_segment_datas, str(env_list[0]),
len(instance_data_filter_list))
if not ret_ip_status:
_change_db_ip_unused(ret_ip_data)
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=ret_ip_msg)
except Exception as e:
_msg = '添加网卡外部接口：获取网段标记ip出现异常 %s: check ip resource exception when instance add nic from platform，err：%s' % (
ip_str, 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:
_change_db_ip_unused(ret_ip_data)
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)
error_msg = []
# 拼装虚拟机网卡信息用于配置网卡
i = 0
for _instance in instance_data_filter_list:
mac = randomMAC()
_instance['ip_addr_new'] = ret_ip_data[i]['ip_address']
_instance['mac_addr'] = mac
i += 1
ret_status, ret_error_msg = __instance_add_netcard(_instance)
if not ret_status:
_msg = {"ip": _instance['instance_ip'], "error_msg": ret_error_msg}
error_msg.append(_msg)
else:
_ip_datas = {
"instanceIp": _instance['instance_ip'],
"nasIp": _instance['ip_addr_new']
}
_ip_datas_list.append(_ip_datas)
if error_msg:
return json_helper.format_api_resp_msg(code=ErrorCode.SYS_ERR,
job_status=VsJobStatus.FAILED,
detail=error_msg)
return json_helper.format_api_resp_msg(code=ErrorCode.SUCCESS,
job_status=VsJobStatus.SUCCEED,
detail=_ip_datas_list)
