def instance_status_change_for_miniarch():
'''
修改虚拟机状态为v2v中，或者关机中
:return:
'''
instance_uuid = request.values.get('instance_uuid')
instance_status = request.values.get('instance_status')
if not instance_uuid or not instance_status:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="请求入参缺失")
if instance_status not in [VMStatus.MINIARCH_MIGRATE, VMStatus.SHUTDOWN]:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="待修改的虚拟机状态无法识别")
ins_data = instance_s.InstanceService().get_instance_info_by_uuid(
instance_uuid)
if not ins_data:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="无法获取虚拟机信息")
# 将克隆源vm状态改成关机
where_data = {'uuid': instance_uuid}
update_data = {'status': instance_status}
ret_change_vm_status = instance_s.InstanceService().update_instance_info(
update_data, where_data)
if ret_change_vm_status < 1:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="虚拟机状态更新失败")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg="虚拟机状态更新成功")
def v2v_openstack_cancel():
#获取入参信息
cancel = request.values.get('cancel')
request_his = request.values.get('request_id')
source = v2v_op.v2vTaskService().get_v2v_task_by_requestid(
request_his)['source']
if cancel != '1':
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='参数错误')
#判断当前任务是否完成
res_task = v2v_op.get_v2v_running_by_reqid(request_his)
if res_task == False:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='任务状态无法操作')
else:
up_cal = v2v_op.updata_v2v_cancel(request_his, 1, 3)
if up_cal == True:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg='取消下发成功')
else:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg='取消下发失败')
def image_create_init():
# 新生成镜像的初始值
kwargs = {'os_type': IMAGE_OS_TYPE, 'os_ver_list': IMAGE_OS_VER}
if not IMAGE_OS_TYPE or not IMAGE_OS_VER:
logging.info('os_type或者os_ver值缺失')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='入参缺失')
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, data=kwargs)
def esx_intodb_batch():
#定义整个函数执行情况的returnlist
check_list = []
error_list = []
#将入参转化为list对象
v2v_list_str = request.values.get('esx_batch')
v2v_list = json.loads(v2v_list_str)
total_num = len(v2v_list)
#对list中每个v2v任务进行vm的信息检测
for task in v2v_list:
check_tag,check_res = esx_vm_check(task)
if not check_tag:
error_list.append(task)
else:
check_list.append(task)
#如果全部失败则直接返回
if check_list == []:
message = "全部失败"
return_info = error_list
return json_helper.format_api_resp(code=ErrorCode.ALL_FAIL, msg=message,data = return_info)
#将检测完后的list按照group_id进行list分组
group_list = task_into_list(check_list)
#针对group分组后的list套用host筛选算法
for task_list in group_list:
tag1,res1 = cal_group_host(task_list)
#如果同group下list套用host算法失败，则将这部分task存入errorlist
if not tag1:
for task in task_list:
task["error_message"] = "host资源不足"
error_list.append(task)
else:
#host筛选完成，进行入库操作
for task in task_list:
tag2,res2 = task_esx_intodb(task)
#如果入库失败，则存入returnlist
if not tag2:
task["error_message"] = res2
error_list.append(task)
#统计总errorlist值
error_num = len(error_list)
if error_num == total_num:
message = "全部失败"
return_code = ErrorCode.ALL_FAIL
elif error_num == 0:
message = "全部成功"
return_code = ErrorCode.SUCCESS
else:
message = "部分成功"
return_code = ErrorCode.SUCCESS
return json_helper.format_api_resp(code=return_code, msg=message,data=error_list)
def inner(*args, **kwargs):
client_ip = request.headers.get('X-Forwarded-For', '')
logging.warn("api ip:" + client_ip)
if not client_ip:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="无法获取请求方IP")
ip_params = {'WHERE_AND': {'=': {'ip_permit': client_ip}}}
permit_ip_nums, permit_ip_datas = request_i_p_s.RequestIpPermitService(
).query_data(**ip_params)
if permit_ip_nums <= 0:
return json_helper.format_api_resp(code=ErrorCode.AUTH_ERROR,
msg="请求应用IP地址无权访问，请联系系统组同事")
return func(*args, **kwargs)
def instance_flavor(instance_id):
'''
获取虚机flavor
:param instance_id:
:return:
'''
if not instance_id:
logging.info('no instance_id when get flavor')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
flavor_data = ins_s.get_flavor_of_instance(instance_id)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
data=flavor_data)
def image_checkout():
eimage_name = request.values.get('image_name')
if not eimage_name:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg='入参缺失')
# 判断当前image状态是否正常
image_manage_data = im_s.ImageManageService().get_img_manage_data_by_name(eimage_name)
os_type = image_manage_data[1]["os_type"]
image_manage_stat = image_manage_data[1]["status"]
if image_manage_stat != ImageManage.EDITING:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg='当前模板机状态不允许此操作')
# template vm remove ip
update_action = im_m_act.IP_REMOVE
ret, message = im_man_act.img_tem_rm_ip(eimage_name, os_type)
if not ret:
state_tag = im_m_act_sta.FAILED
im_s.ImageStatusService().add_image_status_action(eimage_name, update_action, state_tag, message)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=message)
else:
state_tag = im_m_act_sta.SUCCESSED
im_s.ImageStatusService().add_image_status_action(eimage_name, update_action, state_tag, message)
# template vm shutdown
update_action = im_m_act.VEM_SHUTDOWN
ret, message = im_man_act._img_tem_shutdown(eimage_name)
if not ret:
state_tag = im_m_act_sta.FAILED
im_s.ImageStatusService().add_image_status_action(eimage_name, update_action, state_tag, message)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=message)
else:
state_tag = im_m_act_sta.SUCCESSED
im_s.ImageStatusService().add_image_status_action(eimage_name, update_action, state_tag, message)
# 更新template vm状态为关机
update_data = {
'template_status': img_tmp_status.SHUTDOWN
}
where_data = {
'eimage_name': eimage_name
}
im_s.ImageManageService().update_image_info(update_data, where_data)
# 更新template_status
message = ''
im_s.ImageManageService().update_image_manage_status(eimage_name, message, ImageManage.CHECKOUT)
message = '模板机%s 生成模板成功' % eimage_name
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg=message)
def image_console():
"""
虚拟机vnc控制台
:param instance_id:
:return :
"""
"""
if not instance_id:
logging.info('no instance id when get configure info')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR, msg="参数错误")
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
host_ip = ins_s.get_hostip_of_instance(instance_id)
if not ins_data or not host_ip:
logging.info('instance %s data is no exist in db when get configure info', instance_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
instance_name = ins_data['name']
connect_disk_device_get = vmManager.libvirt_get_connect(host_ip, conn_type='instance', vmname=instance_name)
# result, data = vmManager.libvirt_get_vnc_port(connect_disk_device_get, instance_name)
# if not result:
# logging.info(data)
# return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
"""
console_server_host = request.host.split(':')[0]
apple = request.query_string.decode().strip()
peeledapple = apple.split('=')
instance_name = peeledapple[1]
if not console_server_host:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
kvm_host_ip = IMAGE_EDIT_SERVER
# 连接libvirtd查询虚拟机console端口号
connect_instance = vmManager.libvirt_get_connect(kvm_host_ip,
conn_type='instance',
vmname=instance_name)
status, vnc_port = vmManager.libvirt_get_vnc_console(
connect_instance, instance_name)
if not status:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
token = str(kvm_host_ip) + '-' + str(vnc_port)
resp = make_response(
render_template('console-vnc.html',
vm_name=instance_name,
ws_host=console_server_host,
ws_port=6080))
resp.set_cookie('token', token)
return resp
def hostpool_info_init():
hostpool_info = hostpool_service.get_hostpool_info()
for each in hostpool_info:
dc_type = each["env"]
each["env"] = DataCenterTypeTransformCapital.MSG_DICT[int(dc_type)]
return json_helper.format_api_resp(ErrorCode.SUCCESS, data=hostpool_info)
def intodb_batch():
# 定义整个函数执行情况的returnlist
return_list = []
# 将入参转化为list对象
v2v_list_str = request.values.get('openstack_batch')
v2v_list = json.loads(v2v_list_str)
total_num = len(v2v_list)
# 将入参的list按照group_id进行list分组
group_list = task_into_list(v2v_list)
# 针对group分组后的list套用host筛选算法
for task_list in group_list:
tag1, task_list = cal_group_host(task_list)
# 如果同group下list套用host算法失败，则将这部分task存入returnlist
for task in task_list:
if task.get('error_message'):
return_list.append(task)
# 统计总return_list值
error_num = len(return_list)
if error_num == total_num:
message = "全部失败"
return_code = ErrorCode.ALL_FAIL
elif error_num == 0:
message = "全部成功"
return_code = ErrorCode.SUCCESS
else:
message = "部分成功"
return_code = ErrorCode.SUCCESS
return json_helper.format_api_resp(code=return_code, msg=message, data=return_list)
def instance_recreate():
'''
重新创建虚拟机
:return:
'''
instance_id = request.values.get('instance_id')
if not instance_id:
logging.info('no instance_id when recreate instance')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
if not ins_data:
logging.error('no instance %s info when recreate instance',
instance_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def logout():
user_id = current_user.user_id
logout_user()
session.clear()
logging.info('userid: %s is logged out', user_id)
oper_s.add_operation_other(user_id, OperationObject.LOGIN_LOGOUT,
OperationAction.LOGOUT, "SUCCESS")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def instance_os_version_modify(instance_id):
'''
修改os版本为unknown的虚拟机
:param instance_id:
:json param :
:return:
'''
req_json = request.data
req_data = json_helper.loads(req_json)
n_os_version = req_data["os_version"]
if not instance_id or not str(n_os_version):
logging.info(
'no instance_id or os_version when modify instance os version')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
if not ins_data:
logging.error(
'instance %s info is no exist in db when modify instance os version',
instance_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# VM创建来源
create_source = ins_data['create_source']
# 本平台
if create_source == VMCreateSource.OPENSTACK or create_source == VMCreateSource.ESX:
# v2v迁移的VM
ins_v2v_data = v2v_i_i_s.v2vInstanceinfo(
).get_v2v_instance_info_by_instance_id(instance_id)
if ins_v2v_data:
if ins_v2v_data['os_version'] and ins_v2v_data[
'os_version'] == "unknown":
# 更新v2v虚拟机os版本
update_data = {'os_version': n_os_version}
where_data = {'instance_id': instance_id}
v2v_i_i_s.v2vInstanceinfo().update_v2v_status(
update_data, where_data)
else:
# todo: kvm2.0需要增加对平台自身创建虚拟机操作系统版本校验，unknown的可以修改
pass
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg="操作系统版本更新成功")
def get_user():
'''
获取用户登陆状态及信息
:return:
'''
# 已登录
if not current_user.is_anonymous:
user_permisson = user_s.user_permisson(current_user.user_id)
user_data = {
"user_name": current_user.user_name,
"user_id": current_user.user_id,
"user_permisson": user_permisson
}
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
data=user_data)
else:
return json_helper.format_api_resp(code=ErrorCode.AUTH_ERROR,
msg='用户未登录')
def host_perform_data_to_db():
'''
此函数用于将物理机上报上来的性能数据写入数据库
:return:
'''
data_from_host = request.data
data = json_helper.loads(data_from_host)
if not data or not data['ip']:
# 物理机性能数据中ip为空，不做任何操作
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='无法获取上传性能数据中的物理机ip信息，录入性能数据失败')
# ret_msg = _msg_format(host_ip=data['ip'], host_name=data['hostname'], cpu_core=data['cpu_core'],
# mem_size=data['mem_size'], disk_size=data['disk_size'], net_size=data['net_size'],
# current_cpu_used=data['current_cpu_used'],
# current_mem_used=data['current_mem_used'],
# current_disk_used=data['current_disk_used'],
# week_cpu_p95_used=data['week_cpu_p95_used'],
# week_mem_p95_used=data['week_mem_p95_used'],
# current_net_rx_used=data['current_net_rx_used'],
# current_net_tx_used=data['current_net_tx_used'],
# start_time=data['start_time'],
# libvirt_port=data['libvirt_port'],
# libvirt_status=data['libvirt_status'],
# images=data['images'])
# 更新host表
__update_host_table(data['ip'], data['ostype'], data['cpu_core'],
data['mem_size'], data['disk_size'], data['net_size'],
data['current_cpu_used'], data['current_mem_used'],
data['current_disk_used'], data['week_cpu_p95_used'],
data['week_mem_p95_used'], data['current_net_rx_used'],
data['current_net_tx_used'], data['start_time'],
data['libvirt_port'], data['images'],
data['libvirt_status'])
# flush_host_perform_data_to_db(datadict=ret_msg)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg='%s：录入性能数据成功' % data['ip'])
def v2v_openstack_retry():
#获取入参信息
retry = request.values.get('retry')
request_his = request.values.get('request_id')
source = v2v_op.v2vTaskService().get_v2v_task_by_requestid(
request_his)['source']
if not source:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='v2v来源缺失')
if retry != '1':
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='参数错误')
#判断当前任务是否可重试
res_task = v2v_op.get_v2v_retryable(request_his)
if not res_task:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='任务状态无法重试')
else:
if source == VMCreateSource.OPENSTACK:
res_t, res_msg = openstack_retry_action(request_his)
if not res_t:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=res_msg)
else:
res_e, res_emsg = esx_retry_action(request_his)
if not res_e:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=res_emsg)
up_sta = v2v_op.updata_v2v_retry(request_his, 0)
if up_sta == True:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg='重试下发成功')
else:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='重试下发失败')
def instance_excel_del_template():
'''虚拟机批量删除模板'''
# 系统管理员能看到其组所在区域的所有VM
role_ids = current_user_role_ids()
# 系统管理员
if 1 not in role_ids:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="当前用户权限不足，请联系系统组管理员")
sheet = []
excel_data = OrderedDict()
name = " del_instance_template "
title_data = [u"待删除虚拟机ip地址"]
sheet.append(title_data)
for i in [u'10.10.10.10', u'12.12.12.12']:
sheet.append([i])
excel_data.update({name: sheet})
io = StringIO.StringIO()
save_data(io, excel_data)
response = make_response(io.getvalue())
response.headers[
"Content-Disposition"] = "attachment; filename={}.xls".format(name)
response.headers["page-type"] = "download"
return response
def image_create_exist_init():
# 根据已有镜像生成镜像的初始值接口
params = {
'WHERE_AND': {
'in': {
'system': ['linux', 'windows']
},
},
'ORDER': [
['id', 'desc'],
],
}
ret = image_service.ImageService().query_data(**params)
ret_new = ret[1]
for i in ret_new:
for y in i.keys():
if y != 'system' and y != 'version' and y != 'name' and y != 'tag' and y != 'displayname':
del i[y]
news_ids = []
for id in ret_new:
if id not in news_ids:
news_ids.append(id)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, data=news_ids)
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 import_excel_esx():
'''
批量导入excel
:return:
'''
f = request.files['file']
# 判断是excel文件
file_name = f.filename
(file_shortname, file_suffix) = os.path.splitext(file_name)
if file_suffix != ".xls" and file_suffix != ".xlsx":
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="v2v批量操作只支持excel文件，请选择excel文件")
xls_data = get_data(f)
xls_noempty_data = 0
for sheet_n in xls_data.keys():
# 只处理一个sheet数据
if xls_data[sheet_n]:
all_data_list = xls_data[sheet_n]
xls_noempty_data += 1
break
if xls_noempty_data == 0:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="不能上传空excel文件")
all_data_num = len(all_data_list)
if all_data_num < 2:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="请填写相关v2v信息后再提交该excel文件")
user_id = get_user()['user_id']
# todo:处理空列
threads = []
for i, row in enumerate(all_data_list):
# 默认第一行是标题，跳过
if i == 0:
continue
_check_thread = threading.Thread(target=_check_task,
args=(i, row, user_id))
threads.append(_check_thread)
_check_thread.start()
# 判断多线程是否结束
for t in threads:
t.join()
return_msg_list = []
while not q.empty():
return_msg_list.append(q.get())
# 检测返回值有无错误信息
v2v_list = []
return_error_num = 0
return_error_msg_list = []
for _return_msg in return_msg_list:
if _return_msg[0] is False:
return_error_num += 1
return_error_msg_list.append(_return_msg[1])
else:
v2v_list.append(_return_msg[1])
# 只要有一个任务有错误，就返回
if return_error_num > 0:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="任务检测有错误，无法进行v2v操作",
data=return_error_msg_list)
error_num = 0
total_num = len(v2v_list)
# 将入参的list按照group_id进行list分组
group_list = _task_into_list(v2v_list)
# 针对group分组后的list套用host筛选算法
for task_list in group_list:
tag1, res1 = _cal_group_host(task_list)
# 算法分配失败
if not tag1:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=res1)
else:
# host筛选完成，进行入库操作
for task in task_list:
tag2, res2 = _task_esx_intodb(task)
# 入库失败
if not tag2:
error_num += 1
# 统计总错误数
if error_num == total_num:
message = "全部失败"
return_code = ErrorCode.ALL_FAIL
elif error_num == 0:
message = "全部成功"
return_code = ErrorCode.SUCCESS
else:
message = "部分成功"
return_code = ErrorCode.SUCCESS_PART
return json_helper.format_api_resp(code=return_code, msg=message)
def instance_db_info(uuid, vmname, vm_app_info, owner, flavor_id, group_id,
host, mac, vmdisk, ip_id, vmostype, requestid, ver_data):
vm_ostype_todb = ''
vmhost = ho_s.HostService().get_host_info_by_hostip(host)
# 往instance表添加记录
instance_data = {
'uuid': uuid,
'name': vmname,
'displayname': vmname,
'description': '',
'status': VMStatus.CONVERTING,
'typestatus': VMTypeStatus.NORMAL,
'isdeleted': '0',
'app_info': vm_app_info,
'owner': owner,
'created_at': get_datetime_str(),
'create_source': VMCreateSource.OPENSTACK
}
ret = ins_s.InstanceService().add_instance_info(instance_data)
if ret.get('row_num') <= 0:
logging.info(
'add instance info error when create instance, insert_data: %s',
instance_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
instance_id = ret.get('last_id')
if vmostype == 'Windows':
vm_ostype_todb = 'windows'
elif vmostype == 'Linux':
vm_ostype_todb = 'linux'
#往v2v_instance_info表添加记录
v2v_instance_data = {
'instance_id': instance_id,
'os_type': vm_ostype_todb,
'isdeleted': '0',
'created_at': get_datetime_str(),
'request_id': requestid,
'os_version': ver_data
}
ret_v2v_instance = v2v_in_i.v2vInstanceinfo().add_v2v_instance_info(
v2v_instance_data)
if ret_v2v_instance.get('row_num') <= 0:
logging.info(
'add v2v_instance info error when create instance, v2v_instance_data: %s',
v2v_instance_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 往instance_flavor表添加记录
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.info(
'add instance_flavor info error when create instance, insert_data: %s',
instance_flavor_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 往instance_group表添加记录
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.info(
'add instance_group info error when create instance, insert_data: %s',
instance_group_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 往instance_host表添加记录
instance_host_data = {
'instance_id': instance_id,
'instance_name': vmname,
'host_id': vmhost['id'],
'host_name': vmhost['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.info(
'add instance_host info error when create instance, insert_data: %s',
instance_host_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 往instance_ip表添加记录
instance_ip_data = {
'instance_id': instance_id,
'ip_id': ip_id,
'mac': mac,
'type': InstanceNicType.MAIN_NETWORK_NIC,
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret4 = ins_ip_s.InstanceIPService().add_instance_ip_info(instance_ip_data)
if ret4.get('row_num') <= 0:
logging.info(
'add instance_ip info error when create instance, insert_data: %s',
instance_ip_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 往instance_disk表添加记录
instance_disk_data = {
'instance_id': instance_id,
'size_gb': vmdisk,
'mount_point': '',
'dev_name': '',
'isdeleted': '0',
'created_at': get_datetime_str()
}
ret5 = ins_d_s.InstanceDiskService().add_instance_disk_info(
instance_disk_data)
if ret5.get('row_num') <= 0:
logging.info(
'add instance_disk info error when create instance, insert_data: %s',
instance_disk_data)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
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 instance_detail(instance_id):
'''
获取虚机详情
:param instance_id:
:return:
'''
if not instance_id:
logging.info('no instance_id when get instance detail')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
if not ins_data:
logging.error(
'instance %s info is no exist in db when get instance detail',
instance_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# VM创建来源
create_source = ins_data['create_source']
ins_flavor = ins_s.get_flavor_of_instance(instance_id)
if not ins_flavor:
logging.error(
'instance %s flavor info is no exist in db when get instance detail',
instance_id)
cpu = None
memory_mb = None
root_disk_gb = None
else:
cpu = ins_flavor['vcpu']
memory_mb = ins_flavor['memory_mb']
root_disk_gb = ins_flavor['root_disk_gb']
system = None
sys_version = None
image_name = None
# 本平台
if create_source == VMCreateSource.CLOUD_SOURCE:
ins_images = ins_s.get_images_of_instance(instance_id)
if not ins_images:
logging.error(
'instance %s image info is no exist in db when get instance detail',
instance_id)
else:
system = ins_images[0]['system']
sys_version = ins_images[0]['version']
image_name = ins_images[0]['displayname']
elif create_source == VMCreateSource.OPENSTACK or create_source == VMCreateSource.ESX:
# v2v迁移的VM
ins_v2v_data = v2v_i_i_s.v2vInstanceinfo(
).get_v2v_instance_info_by_instance_id(instance_id)
if ins_v2v_data:
system = ins_v2v_data['os_type']
sys_version = ins_v2v_data['os_version']
ins_group = ins_s.get_group_of_instance(instance_id)
if not ins_group:
logging.error(
'instance %s group info is no exist in db when get instance detail',
instance_id)
group_name = None
else:
group_name = ins_group['name']
ins_ip = ins_s.get_ip_of_instance(instance_id)
if not ins_ip:
logging.error(
'instance %s ip info is no exist in db when get instance detail',
instance_id)
ip_address = None
else:
ip_address = ins_ip['ip_address']
ins_netarea = ins_s.get_netarea_of_instance(instance_id)
if not ins_netarea:
logging.error(
'instance %s net area info is no exist in db when get instance detail',
instance_id)
net_area = None
else:
net_area = ins_netarea['name']
ins_disks = ins_s.get_disks_of_instance(instance_id)
if not ins_disks:
logging.error(
'instance %s disks info is no exist in db when get instance detail',
instance_id)
disk_gb = None
else:
# disk_gb = ins_disks[0]['size_gb']
disk_gb = sum([int(i['size_gb']) for i in ins_disks])
ins_datacenter = ins_s.get_datacenter_of_instance(instance_id)
if not ins_datacenter:
logging.error(
'instance %s datacenter info is no exist in db when get instance detail',
instance_id)
dc_type = None
else:
dc_type = ins_datacenter['dc_type']
data = {
'instance_name': ins_data['name'],
'uuid': ins_data['uuid'],
'ip_address': ip_address,
'dc_type': dc_type,
'net_area': net_area,
'system': system,
'sys_version': sys_version,
'image_name': image_name,
'cpu': cpu,
'memory_mb': memory_mb,
'root_disk_gb': root_disk_gb,
'disk_gb': disk_gb,
'app_info': ins_data['app_info'],
'owner': ins_data['owner'],
'group_name': group_name,
'create_source': create_source
}
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, data=data)
def instance_create(hostpool_id):
'''
创建虚机
:param hostpool_id:
:return:
'''
image_name = request.values.get('image_name')
flavor_id = request.values.get('flavor_id')
disk_gb = request.values.get('disk_gb')
count = request.values.get('count')
app_info = request.values.get('app_info')
group_id = request.values.get('group_id')
owner = request.values.get('owner')
password = request.values.get('password')
task_id = ins_s.generate_task_id()
logging.info(
'创建VM 步骤1：检查参数 task %s : check params start when create instance',
task_id)
if not hostpool_id or not image_name or not flavor_id or not disk_gb or not group_id \
or not count or int(count) < 1:
logging.error(
'创建VM 步骤1：检查参数失败 参数错误 task %s : params are invalid when create instance',
task_id)
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='参数错误')
if int(count) > int(INSTANCE_MAX_CREATE):
logging.error(
'创建VM 步骤1：检查参数失败 批量创建数超过最大数 '
'task %s : create count %s > max num %s when create instance',
task_id, count, INSTANCE_MAX_CREATE)
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg='批量创建最大实例数不能超过' +
INSTANCE_MAX_CREATE + '个')
owner_exist = user_s.UserService().check_userid_exist(owner)
if not owner_exist:
logging.error(
'创建VM 步骤1：检查参数失败 应用管理员工号不存在 '
'task %s : no such user %s in db when create instance', task_id,
owner)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='应用管理员工号不存在，无法创建实例')
logging.info(
'创建VM 步骤1：检查参数成功 task %s : check params successful when create instance',
task_id)
# 数据盘最少50GB
# todo:这里只是一个数据盘，后面有多个数据盘
vm_disk_gb = int(disk_gb) if int(disk_gb) > DATA_DISK_GB else DATA_DISK_GB
# 获取主机列表(不包括锁定、维护状态)
logging.info(
'创建VM 步骤2：获取集群所有HOST列表 '
'task %s : get all hosts in hostpool %s start when create instance',
task_id, hostpool_id)
all_hosts_nums, all_hosts_data = host_s.HostService(
).get_available_hosts_of_hostpool(hostpool_id)
# 可用物理机数量不足
least_host_num = hostpool_service.HostPoolService().get_least_host_num(
hostpool_id)
if all_hosts_nums < least_host_num or all_hosts_nums < 1:
logging.error(
'创建VM 步骤2：获取集群所有HOST列表失败 集群不够资源 '
'task %s : available host resource not enough when create instance',
task_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='集群不够资源，无法创建实例')
logging.info(
'创建VM 步骤2：获取集群所有HOST列表成功，总host数：%s '
'task %s : get all hosts in hostpool %s successful, all hosts nums %s when create instance',
all_hosts_nums, task_id, hostpool_id, all_hosts_nums)
# 过滤host
logging.info(
'创建VM 步骤3：HOST过滤 task %s : filter hosts start when create instance',
task_id)
hosts_after_filter = host_s_s.filter_hosts(all_hosts_data)
if len(hosts_after_filter
) == 0 or len(hosts_after_filter) < least_host_num:
logging.error(
'创建VM 步骤3：HOST过滤失败 没有合适主机 '
'task %s : no available host when create instance', task_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='集群物理机资源无法满足你的申请需求，请联系系统组同事')
logging.info(
'创建VM 步骤3：HOST过滤成功 task %s : filter hosts successful when create instance',
task_id)
# 获取flavor信息
logging.info(
'创建VM 步骤4：获取必需信息 task %s : get need info start when create instance',
task_id)
flavor_info = flavor_service.FlavorService().get_flavor_info(flavor_id)
if not flavor_info:
logging.error(
'创建VM 步骤4：获取必需信息失败 实例规格数据有误 '
'task %s : flavor %s info not in db when create instance', task_id,
flavor_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='实例规格数据有误，无法创建实例')
# VM分配给HOST
logging.info(
'创建VM 步骤5：HOST分配 task %s : match hosts start when create instance',
task_id)
vm = {
"vcpu": flavor_info['vcpu'],
"mem_MB": flavor_info['memory_mb'],
"disk_GB": flavor_info['root_disk_gb'] + vm_disk_gb, # 系统盘加数据盘
"group_id": group_id,
"count": count
}
host_list = host_s_s.match_hosts(hosts_after_filter,
vm,
least_host_num=least_host_num,
max_disk=2000)
host_len = len(host_list)
if host_len == 0:
logging.error(
'创建VM 步骤5：HOST分配失败 没有合适主机 '
'task %s : match host resource not enough when create instance',
task_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='集群物理机资源无法满足你的申请需求，请联系系统组同事')
logging.info(
'创建VM 步骤5：HOST分配成功 task %s : match hosts successful when create instance',
task_id)
# 获取hostpool的net area信息
hostpool_info = hostpool_service.HostPoolService().get_hostpool_info(
hostpool_id)
if not hostpool_info:
logging.error(
'创建VM 步骤6：获取必需信息失败 物理机池所属网络区域信息有误 '
'task %s : hostpool %s info not in db when create instance',
task_id, hostpool_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='物理机池所属网络区域信息有误，无法创建实例')
net_area_id = hostpool_info['net_area_id']
logging.info(
'创建VM 步骤6：获取必需信息成功 task %s : get need info successful when create instance',
task_id)
# 组配额控制
logging.info(
'创建VM 步骤7：检查组配额 task %s : check group quota start when create instance',
task_id)
is_quota_enough, quota_msg = check_group_quota(group_id, flavor_info,
vm_disk_gb, count)
if not is_quota_enough:
logging.error(
'创建VM 步骤7：检查组配额失败 配额不足 '
'task %s : group %s is no enough quota when create instance',
task_id, group_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=quota_msg)
logging.info(
'创建VM 步骤7：检查组配额成功 task %s : check group quota successful when create instance',
task_id)
logging.info(
'创建VM 步骤8：获取必需信息 task %s : get need 1 info start when create instance',
task_id)
# 获取镜像信息，一个image_name可能对应多个id
image_nums, image_data = image_service.ImageService().get_images_by_name(
image_name)
if image_nums <= 0:
logging.info(
'创建VM 步骤8：获取必需信息失败 镜像资源不足 '
'task %s : no image %s info in db when create instance', task_id,
image_name)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='没有镜像资源，无法创建实例')
# 实例操作系统
instance_system = image_data[0]['system']
logging.info(
'创建VM 步骤8：获取必需信息成功 '
'task %s : get need 1 info successful when create instance', task_id)
# 获取集群所在的环境
vm_env = hostpool_service.get_env_of_hostpool(hostpool_id)
# hostpool对应的机房名
dc_name = hostpool_service.get_dc_name_of_hostpool(hostpool_id)
# 获取集群所在网络区域名
net_area_name = hostpool_service.get_level_info_by_id(hostpool_id).get(
'net_area_name', '')
# 获取虚机名资源
logging.info(
'创建VM 步骤9：获取主机名资源 '
'task %s : check instance name resource start when create instance',
task_id)
is_name_enough, instance_name_list = _check_instance_name_resource(
vm_env, dc_name, instance_system, count)
if not is_name_enough:
logging.error(
'创建VM 步骤9：获取主机名资源失败 主机名资源不足 '
'task %s : datacenter %s has no enough instance name resource',
task_id, dc_name)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='主机名资源不足，无法创建实例')
logging.info(
'创建VM 步骤9：获取主机名资源成功 '
'task %s : check instance name resource successful when create instance',
task_id)
# 获取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(
'创建VM 步骤10：检查IP时无法获取资源锁状态'
'task %s : check ip resource can not get lock', task_id)
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)
try:
ret_ips_status, ret_ips_data, ret_segment = __check_ip_resource(
vm_env, dc_name, net_area_name, count)
except Exception as e:
_msg = '创建VM 步骤10：检查IP资源是否足够出现异常task_id %s: check ip resource exception when instance create，err：%s' % (
task_id, 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_ips_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=ret_ips_data)
# 更新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)
ips_list = ret_ips_data
segment_data = ret_segment
logging.info(
'创建VM 步骤10：检查IP资源成功 task %s : check ip resource successful when create instance',
task_id)
# 挂载点
if instance_system == 'linux':
mount_point = '/app'
else:
mount_point = 'E'
logging.info(
'创建VM 步骤11：多线程发送创建信息 task %s : create thread start when create instance',
task_id)
user_id = get_user()['user_id']
all_threads = []
for i in range(int(count)):
instance_name = str(instance_name_list[i])
ip_data = ips_list[i]
# 轮询host
index = i % host_len
vm_host = host_list[index]
create_ins_t = threading.Thread(
target=_create_instance_info,
args=(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),
name='thread-instance-create-' + task_id)
all_threads.append(create_ins_t)
create_ins_t.start()
for thread in all_threads:
thread.join()
logging.info(
'创建VM 步骤11：多线程发送创建信息成功 '
'task %s : create thread successful when create instance', task_id)
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
def image_edit():
eimage_name = request.values.get('image_name')
if not eimage_name:
# message = {
# 'code': ErrorCode.SYS_ERR,
# 'msg': "入参缺失"
# }
# socketio.emit('image_edit_resp', message, namespace='/image_edit_return')
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg='入参缺失')
# 判断当前image状态是否正常
image_manage_data = im_s.ImageManageService().get_img_manage_data_by_name(
eimage_name)
image_manage_stat = image_manage_data[1]["status"]
image_manage_type = image_manage_data[1]["os_type"]
image_manage_osver = image_manage_data[1]["version"]
enable_stat = [ImageManage.INIT, ImageManage.CHECKOUT, ImageManage.USABLE]
if image_manage_stat not in enable_stat:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='当前模板机状态不允许此操作')
# template vm start
ret, message = im_man_act._img_tem_start(eimage_name)
update_action = im_m_act.START_VEM
if not ret:
state_tag = im_m_act_sta.FAILED
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, message)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=message)
else:
state_tag = im_m_act_sta.SUCCESSED
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, message)
# update template vm stat
update_data = {'template_status': img_tmp_status.RUNNING}
where_data = {'eimage_name': eimage_name}
im_s.ImageManageService().update_image_info(update_data, where_data)
# template vm inject ip
ret, res_data = im_s.ImageManageService().get_img_manage_data_by_name(
eimage_name)
update_action = im_m_act.IP_INJECT
if not ret:
state_tag = im_m_act_sta.FAILED
error_msg = res_data
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, error_msg)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='获取镜像信息失败')
ip_address = res_data['template_vm_ip']
segment_data = segment_s.SegmentService().get_segment_for_img_tmp()
if not segment_data:
error_msg = '获取镜像模板专用网段失败'
state_tag = im_m_act_sta.FAILED
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, error_msg)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg='获取镜像模板专用网段失败')
netmask_int = int(segment_data['netmask'])
netmask = exchange_maskint(netmask_int)
gateway = segment_data['gateway_ip']
dns1 = segment_data['dns1']
dns2 = segment_data['dns2']
res, message = im_man_act._img_tem_inject(eimage_name, ip_address, netmask,
gateway, image_manage_type,
image_manage_osver, dns1, dns2)
update_action = im_m_act.IP_INJECT
if not res:
error_msg = message
state_tag = im_m_act_sta.FAILED
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, error_msg)
im_s.ImageManageService().update_image_manage_msg(eimage_name, message)
msg = '模板机%s 初始化注入失败' % eimage_name
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=msg)
else:
state_tag = im_m_act_sta.SUCCESSED
im_s.ImageStatusService().add_image_status_action(
eimage_name, update_action, state_tag, message)
# 更新template_status
message = ''
im_s.ImageManageService().update_image_manage_status(
eimage_name, message, ImageManage.EDITING)
message = '模板机%s 开机编辑成功' % eimage_name
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg=message)
def task_check():
# 入参赋值
vmip = request.values.get('vm_ip')
flavor_id = request.values.get('flavor_id')
cloudarea = request.values.get('cloud_area')
vm_ostype = request.values.get('vm_ostype')
vm_segment = request.values.get('segment')
# 入参完全性判断
if not vmip or not flavor_id or not cloudarea or not vm_ostype or not vm_segment:
logging.info('params are invalid or missing')
message = '入参缺失'
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg=message)
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)
message = '实例规格数据有误，无法进行v2v'
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg=message)
# 获取对应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:
message = 'openstack环境参数错误，无法进行v2v操作'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
# 判断vm信息是否输入错误
vmexist = vm_exist(vmip, ctr_host, ctr_pass)
if vmexist == False:
message = '获取vm信息失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
# 获取OS版本失败
osstat, verdata = get_vm_version(ctr_host, ctr_pass, vm_ostype, vmip)
if osstat == False:
message = '获取vmOS版本失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
else:
ver_data = verdata
# 获取待迁移vm磁盘大小
vdiskdata = vm_disk_size(vmip, cloudarea, ctr_host, ctr_pass)
if vdiskdata == False:
message = '获取vm磁盘信息失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
vdisk = vdiskdata
data_disk = vdisk - 80
# 判断待转化vm是否关机
vmshutdown = vm_stat(vmip, ctr_host, ctr_pass)
if vmshutdown == False:
message = '待转化vm未关机'
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:
message = '网段信息有误，无法进行v2v'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
else:
ip_data = ip_s.IPService().get_ip_info_by_ipaddress(vmip)
if ip_data:
ip_data_status = ip_data['status']
if ip_data_status != '0':
message = "IP与现有环境冲突,无法进行v2v"
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg=message)
return_info = {'vm_osver': ver_data, 'vm_disk': str(data_disk)}
message = "获取VM信息成功"
return json_helper.format_api_resp(code=ErrorCode.SUCCESS,
msg=message,
data=return_info)
def host_image_task_intodb():
#获取单台host的入库信息
front_data = request.get_data()
front_data_dict = json.loads(front_data)
host_id = front_data_dict['host_id']
image_list = front_data_dict['image_list']
if not host_id or not image_list:
err_msg = '入参缺失'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=err_msg)
#判断host_id是否异常
host_data = host_s.HostService().get_host_info(host_id)
host_ip = host_data['ipaddress']
if not host_data:
err_msg = '获取host信息失败'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=err_msg)
#定义两个list来存成功的image_task和失败的image_task
correct_image_task_list = []
error_image_task_list = []
# #判断前台发来的image_list总长度不能大于7
# image_list_num = len(image_list)
# if int(image_list_num) > 7 :
# err_msg = 'image任务数量不能大于7'
# return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=err_msg)
#判断前台传输的image id信息是否有重复值
image_id_rep_check = image_id_check_rep(image_list)
if not image_id_rep_check:
err_msg = '同步任务中出现重复的image id记录'
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR, msg=err_msg)
# 判断镜像信息是否异常
for image_task_info in image_list:
image_id = image_task_info['image_id']
image_info = im_s.ImageService().get_image_info(image_id)
#如果判断image_id异常
if not image_info:
err_msg = '获取镜像id为' + image_id + '信息失败'
err_data = {
'image_task': image_task_info,
'error_message': err_msg
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
else:
#判断新增任务时间是否异常
res, msg = check_new_task_time(image_task_info, host_id, image_id)
if not res:
err_msg = msg
err_data = {
'image_task': image_task_info,
'error_message': err_msg
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
print 1
#针对check后的任务清单做入库处理
for image_task_info in image_list:
# 判断任务是新增还是加入计划任务
image_id = image_task_info['image_id']
image_task_ondo = im_sy_s.get_ondo_task(host_ip, image_id)
#如果为新增任务
if not image_task_ondo:
task_start_time_str = image_task_info['start_time']
task_start_time = datetime.strptime(task_start_time_str,
"%Y-%m-%d %X")
task_info_list = image_task_info['task_list']
task_num = len(task_info_list)
#判断计划任务数是否大于7
if task_num > 7:
image_info = im_s.ImageService().get_image_info(image_id)
image_name = image_info['name']
image_descrp = image_info['description']
err_msg = '该image ' + image_name + ' ' + image_descrp + ' 所添加的计划任务数量大于7'
err_data = {
'error_message': err_msg,
'image_task': image_task_info
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
speed_limit = image_task_info['speed_limit']
host_ip = host_s.HostService().get_host_info(host_id)['ipaddress']
#将每个image_task入image_sync_task表
insert_data = {
'image_id': image_id,
'host_ip': host_ip,
'status': '0',
'type': '1',
'schedule_num': task_num,
'start_time': task_start_time,
'isdeleted': '0',
'on_task': '0',
'speed_limit': speed_limit,
'process_id': 'undefined'
}
res1 = im_sy_s.ImageSyncService().add_image_sync_task(insert_data)
if not res1:
message = '插入image_sync_task表失败'
err_data = {
'image_task': image_task_info,
'error_message': message
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
#如入image_sync_task表成功，则继续入image_sync_schedult表
else:
image_sync_task_id = res1.get('last_id')
for sch_task in task_info_list:
sch_starttime_str = sch_task['sch_starttime']
sch_endtime_str = sch_task['sch_endtime']
sch_starttime = datetime.strptime(sch_starttime_str,
"%Y-%m-%d %X")
sch_endtime = datetime.strptime(sch_endtime_str,
"%Y-%m-%d %X")
insert_data = {
'image_task_id': image_sync_task_id,
'sch_state': '0',
'sch_starttime': sch_starttime,
'sch_endtime': sch_endtime,
'isdeleted': '0'
}
res = im_sy_sch.ImageSyncScheduleService(
).add_image_sync_sch(insert_data)
#如果入库失败则跳出循环并将上步入库的task_sync表的isdeleted置为1
if not res:
where_data = {'id': image_sync_task_id}
update_data = {'isdeleted': '1'}
im_sy_s.ImageSyncService().update_image_sync_task(
update_data, where_data)
err_msg = '插入计划任务失败'
err_data = {
'error_message': err_msg,
'image_task': image_task_info
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
error_image_task_list.append(err_data)
break
#如果已存在image_id,只是新增计划任务
else:
#获取当前image_id下在running的计划任务数
image_sync_task_id = image_task_ondo[0]['id']
sch_ondo_num, sch_ondo_data = im_sy_sch.get_ondo_sch_list(
image_sync_task_id)
#判断前台输入的image任务数量是否大于当前可添加的数量
sch_add_num = len(image_task_info['task_list'])
if sch_add_num + sch_ondo_num > 7:
image_info = im_s.ImageService().get_image_info(image_id)
image_name = image_info['name']
image_descrp = image_info['description']
message = '镜像' + image_name + ' ' + image_descrp + '可添加任务数量大于最大值'
err_data = {
'image_task': image_task_info,
'error_message': message
}
error_image_task_list.append(err_data)
image_list.remove(image_task_info)
#如果前台输入的计划任务数量不超过最大值则入库
else:
task_info_list = image_task_info['task_list']
for sch_task in task_info_list:
sch_starttime_str = sch_task['sch_starttime']
sch_endtime_str = sch_task['sch_endtime']
sch_starttime = datetime.strptime(sch_starttime_str,
"%Y-%m-%d %X")
sch_endtime = datetime.strptime(sch_endtime_str,
"%Y-%m-%d %X")
insert_data = {
'image_task_id': image_sync_task_id,
'sch_state': '0',
'sch_starttime': sch_starttime,
'sch_endtime': sch_endtime,
'isdeleted': '0'
}
im_sy_sch.ImageSyncScheduleService().add_image_sync_sch(
insert_data)
#统计总的入库成功list和失败list并返回给前台
for image_task in image_list:
correct_image_task_list.append(image_task)
#计算总的失败数
total_image_task_num = len(image_list)
total_fail_task_num = len(error_image_task_list)
if total_image_task_num == 0:
tag = ErrorCode.ALL_FAIL
else:
tag = ErrorCode.SUCCESS
return_data = {
'fail_task_num': str(total_fail_task_num),
'fail_task_list': error_image_task_list,
'succss_task_list': correct_image_task_list
}
return json_helper.format_api_resp(code=tag, data=return_data)
def upload_del_instance_excel():
'''导入批量删除的虚拟机ip，虚拟机需关机一个月无任何操作'''
g = Global_define()
g.init()
g.set_value('vm_list', [])
# 系统管理员能看到其组所在区域的所有VM
role_ids = current_user_role_ids()
# 系统管理员
if 1 not in role_ids:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="当前用户权限不足，请联系系统组管理员")
if not request.files:
return json_helper.format_api_resp(ErrorCode.PARAM_ERR, msg="请求入参缺失")
f = request.files['file']
file_name, file_suffix = os.path.splitext(f.filename)
if file_suffix != '.xls' and file_suffix != '.xlsx':
return json_helper.format_api_resp(code=ErrorCode.ALL_FAIL,
msg="导入规则的文件格式必须为excel格式")
xls_data = get_data(f)
xls_noempty_data = 0
all_data_list = []
for sheet_n in xls_data.keys():
# 只处理一个sheet数据
if xls_data[sheet_n]:
all_data_list = xls_data[sheet_n]
xls_noempty_data += 1
break
if xls_noempty_data == 0:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="不能上传空excel文件")
if len(all_data_list) < 2:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR,
msg="请填写需删除虚拟机IP后再提交该excel文件")
err_data = []
ins_data_list = []
ip_data_list = []
now_time = get_datetime_now()
for i, rows in enumerate(all_data_list):
# 默认第一行为标题，跳过
if i != 0:
ret_ins = instance_service.get_instance_info_by_ip(rows[0])
if ret_ins:
shut_down_time = ret_ins['shut_down_time']
if (now_time - shut_down_time).days >= 30:
ins_data_list.append(ret_ins)
ip_data_list.append(rows[0])
continue
else:
err_data.append(rows[0])
else:
err_data.append(rows[0])
if err_data:
return json_helper.format_api_resp(
code=ErrorCode.SYS_ERR,
msg="以下的虚拟机ip不符合条件，请检测ip是否存在或关机无操作30天：{}".format(err_data))
g.set_value("vm_list", ip_data_list)
fail_num = 0
all_num = len(ins_data_list)
for _ins_data in ins_data_list:
_ret_del = ins_a_s.delete_instance(_ins_data, _ins_data['status'])
if not _ret_del:
fail_num += 1
continue
# 全失败
if fail_num == all_num:
logging.error("delete instance all failed")
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="导入excel删除虚拟机全部失败")
# 部分成功
if 0 < fail_num < all_num:
logging.error("delete instance part failed")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS_PART,
msg="导入excel删除虚拟机部分失败")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS, msg="全部删除成功")
def console():
"""
虚拟机vnc控制台
:param instance_id:
:return :
"""
"""
if not instance_id:
logging.info('no instance id when get configure info')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR, msg="参数错误")
ins_data = ins_s.InstanceService().get_instance_info(instance_id)
host_ip = ins_s.get_hostip_of_instance(instance_id)
if not ins_data or not host_ip:
logging.info('instance %s data is no exist in db when get configure info', instance_id)
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
instance_name = ins_data['name']
connect_disk_device_get = vmManager.libvirt_get_connect(host_ip, conn_type='instance', vmname=instance_name)
# result, data = vmManager.libvirt_get_vnc_port(connect_disk_device_get, instance_name)
# if not result:
# logging.info(data)
# return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
"""
console_server_host = request.host.split(':')[0]
apple = request.query_string.decode().strip()
peeledapple = apple.split('=')
instance_uuid = peeledapple[1]
if not instance_uuid or not console_server_host:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ins_info = InstanceService().get_instance_info_by_uuid(instance_uuid)
if not ins_info:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
kvm_host_ip = get_hostip_of_instance(ins_info['id'])
if not kvm_host_ip:
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
# 连接libvirtd查询虚拟机console端口号
connect_instance = vmManager.libvirt_get_connect(kvm_host_ip,
conn_type='instance',
vmname=ins_info['name'])
status, vnc_port = vmManager.libvirt_get_vnc_console(
connect_instance, ins_info['name'])
if not status:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
token = str(kvm_host_ip) + '-' + str(vnc_port)
resp = make_response(
render_template('console-vnc.html',
vm_name=ins_info['name'],
ws_host=console_server_host,
ws_port=6080))
resp.set_cookie('token', token)
# 添加操作记录: try.. except .. 部分
try:
user = user_service.get_user()
extra_data = "name:" + ins_info['name'] + "," + "uuid:" + peeledapple[1]
add_operation_other(user["user_id"], OperationObject.VM,
OperationAction.CONSOLE, "SUCCESS", extra_data)
except:
pass
return resp
def instance_delete():
'''
虚机删除
关机超过一天才能删除
:return:
'''
request_from_vishnu = False
if get_user()['user_id'] == 'vishnu':
is_admin = True
request_from_vishnu = True
else:
# 判断操作用户身份
role_ids = current_user_role_ids()
# 系统管理员
if 1 in role_ids:
is_admin = True
else:
is_admin = False
permission_limited = False
ins_ids = request.values.get('instance_ids')
if not ins_ids:
logging.info('no instance_ids when delete instance')
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
ins_ids_list = ins_ids.split(',')
# 操作的instance数
all_num = len(ins_ids_list)
if all_num > int(INSTANCE_MAX_DELETE):
logging.info('delete nums %s is greater than max %s', all_num,
INSTANCE_MAX_DELETE)
return json_helper.format_api_resp(code=ErrorCode.PARAM_ERR)
fail_num = 0
for _ins_id in ins_ids_list:
# 查询虚拟机对应环境信息，应用管理员不能删除非DEV环境虚拟机
ins_group = ins_s.get_group_of_instance(_ins_id)
if not ins_group:
logging.error(
'instance %s group data is no exist in db when delete instance',
str(_ins_id))
fail_num += 1
continue
else:
if not is_admin and int(
ins_group['dc_type']) != DataCenterType.DEV:
permission_limited = True
fail_num += 1
continue
_ins_data = ins_s.InstanceService().get_instance_info(_ins_id)
if _ins_data:
# 维石只能删除克隆备份的虚拟机
if request_from_vishnu and 'clone' not in _ins_data['name']:
fail_num += 1
continue
_ret_del = ins_a_s.delete_instance(_ins_data, _ins_data['status'])
if not _ret_del:
fail_num += 1
continue
else:
logging.error(
'the instance is not exist in db when delete instance')
fail_num += 1
continue
# 全失败
if fail_num == all_num:
logging.error("delete instance all failed")
if permission_limited:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR,
msg="非DEV环境虚拟机请联系系统组删除")
elif request_from_vishnu:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
else:
return json_helper.format_api_resp(code=ErrorCode.SYS_ERR)
# 部分成功
if 0 < fail_num < all_num:
logging.error("delete instance part failed")
if permission_limited:
return json_helper.format_api_resp(
code=ErrorCode.SUCCESS_PART,
msg="部分虚拟机删除成功, 非DEV环境虚拟机请联系系统组删除")
elif request_from_vishnu:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
else:
return json_helper.format_api_resp(code=ErrorCode.SUCCESS_PART,
msg="部分虚拟机删除成功")
return json_helper.format_api_resp(code=ErrorCode.SUCCESS)
