def delete_remote_storage(self, uuid):
ret = server_post("/api/v1/remote_storage/delete", {"uuid": uuid})
if ret.get("code", -1) != 0:
return get_error_result("RemoteStorageDeleteFail",
reason=ret.get("msg"))
else:
return get_error_result("Success")
def get(self, request, *args, **kwargs):
try:
upgrades = YzyTerminalUpgrade.objects.filter(deleted=False).exclude(platform="VOI").all()
ser = YzyTerminalUpgradeSerializer(instance=upgrades, many=True, context={'request': request})
return JSONResponse(get_error_result("Success", ser.data))
except Exception as e:
return JSONResponse(get_error_result("OtherError"))
def check_node(self, data):
"""
data: {
"ip": "172.16.1.49",
"root_pwd" : "xxxxxx"
}
:param data:
:return:
"""
logger.info("check node KVM: %s" % data)
ip = data.get("ip")
root_pwd = data.get("root_pwd")
if not ip or not is_ip_addr(ip):
logging.error("check node parameter ip error: %s" % ip)
return get_error_result("IPAddrError", ipaddr=ip)
# ret['msg'] = ret['msg'].format({"ipaddr": ip})
# return ret
if not root_pwd:
logging.error("check node parameter root_pwd not exist!")
return get_error_result("ParamError")
ret = server_post("/api/v1/node/check", data)
if ret.get('code') != 0:
logger.info("check node KVM failed:%s", ret['msg'])
return ret
logger.info("check node KVM success, ip: %s", ip)
return ret
def delete_terminal(self, data):
""" 删除终端 """
try:
mac_list, name_list = self.get_terminal_mac_name_list(data)
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("ParamError")
mac_list_str = ",".join(mac_list)
# 提交终端服务接口
req_data = {
"handler": "WebTerminalHandler",
"command": "delete",
"data": {
"mac_list": mac_list_str,
}
}
ret = terminal_post("/api/v1/terminal/task", req_data)
msg = "删除终端 %s" % "/".join(name_list)
insert_operation_log(msg, ret["msg"])
if ret.get("code", -1) != 0:
logger.error("terminal close fail: %s" % mac_list_str)
return get_error_result("TerminalCloseOperateError")
logger.info("terminal delete success!!! %s" % mac_list_str)
return get_error_result("Success")
def poll_log_terminal(self, data):
try:
mac_list, name_list = self.get_terminal_mac_name_list(data)
if not mac_list:
raise Exception("terminals not exist")
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("ParamError")
start_date = datetime.datetime.now().strftime("%Y-%m-%d")
log_dir = constants.TERMINAL_LOG_PATH
for mac in mac_list:
terminal = YzyTerminal.objects.filter(deleted=False,
mac=mac).first()
if terminal.status == '0':
continue
ok_file = os.path.join(log_dir, "%s_%s.ok" % (mac, start_date))
if not os.path.exists(ok_file):
return get_error_result("TerminalLogNotExist")
# 打包日志
tar_file = "%s.tar.gz" % start_date
tar_file_path = os.path.join(constants.TERMINAL_LOG_PATH, tar_file)
tar = tarfile.open(tar_file_path, "w:gz")
for mac in mac_list:
log_file = os.path.join(log_dir, "%s_%s.zip" % (mac, start_date))
if os.path.exists(log_file):
tar.add(log_file)
tar.close()
# 查找主控节点
host = self.get_all_object(YzyNodes, {"type": [1, 3]}, False)
down_url = "http://%s:%s/api/v1.0/terminal_mgr/terminal_log/?file=%s" % (
host.ip, constants.WEB_DEFAULT_PORT, tar_file)
return get_error_result("Success", {"down_url": down_url})
def start_sort_terminal(self, data):
group_uuid = data.get("group_uuid", "")
start_num = data.get("index_start")
if not (group_uuid and start_num) or not isinstance(start_num, int):
logger.error("terminal sort number error: param error")
return get_error_result("ParamError")
# 判断组的存在
group = self.get_object_by_uuid(YzyGroup, group_uuid)
if not group:
logger.error("terminal sort number error: %s group not exist" %
group_uuid)
return get_error_result("TerminalWebGroupNotExist")
req_data = {
"handler": "WebTerminalHandler",
"command": "terminal_order",
"data": {
"group_uuid": group_uuid,
"start_num": start_num
}
}
ret = terminal_post("/api/v1/terminal/task", req_data)
msg = "分组 %s 终端排序" % group.name
insert_operation_log(msg, ret["msg"])
if ret.get("code", -1) != 0:
logger.error("terminal update name fail")
return ret
logger.info("terminal sort number success!!! %s" % group.name)
return ret
def put(self, request, *args, **kwargs):
role_id = kwargs.get("role")
user = request.user
options = request.data.get("options")
if not (role_id and options):
logger.error("update permission fail: parameter error")
ret = get_error_result("ParameterError")
return JSONResponse(ret, status=status.HTTP_200_OK)
role = YzyRole.objects.filter(deleted=False, id=role_id).first()
if not role:
logger.error("update permission fail: role not exist")
ret = get_error_result("RoleNotExistError")
return JSONResponse(ret, status=status.HTTP_200_OK)
if not user.is_superuser:
ret = get_error_result("SuperAdminOnlySetError")
return JSONResponse(ret, status=status.HTTP_200_OK)
menu_ids = []
self.get_ids(options, menu_ids)
_menus = self.get_menus(menu_ids)
try:
role.menus.clear()
except Exception as e:
logger.error("update permission fail: %s" % e, exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret, status=status.HTTP_200_OK)
for menu in _menus:
p = YzyRolePermission(role=role, menu=menu)
p.save()
ret = {"code": 0, "msg": "成功"}
return JSONResponse(ret, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
ret = get_error_result("Success")
_data = request.data
password = _data.get("password")
if not password:
# ex = Exception("not input password!")
logger.error("create admin user error: not password input")
ret = get_error_result("NotPasswordInputError")
# return JSONResponse(ret)
else:
_data.update({"password": create_md5(password)})
ser = YzyAdminUserSerializer(data=_data,
context={'request': request})
if ser.is_valid():
ser.save()
# return Response(ser.data, status=status.HTTP_201_CREATED)
# return JSONResponse()
else:
msg = ser.errors
ret = get_error_result("ParamError")
ret["msg"] = msg
logger.info("create admin user: %s" % ret)
msg = "创建管理员用户: %s" % _data.get("username")
insert_operation_log(msg, ret)
return JSONResponse(ret)
def put(self, request, *args, **kwargs):
try:
_data = request.data
user_id = _data.get("user_id")
user = self.get_object(user_id)
if not user:
logger.error("admin user not exist: %s" % user_id)
ret = get_error_result("AdminUserNotExist")
return ret
# username = _data.get("username") or None
real_name = _data.get("real_name") or None
password = _data.get("password") or None
role_id = _data.get("role") or None
desc = _data.get("desc", "") or None
email = _data.get("email", "") or None
# if username: user.username = username
if real_name is not None: user.real_name = real_name
if password: user.password = create_md5(password)
if role_id: user.role_id = role_id
if desc is not None: user.desc = desc
if email is not None: user.email = email
user.save()
ret = get_error_result()
msg = "修改管理员用户信息: %s" % user_id
insert_operation_log(msg, ret)
return JSONResponse(ret)
except Exception as e:
logger.error("", exc_info=True)
return JSONResponse(get_error_result("OtherError"))
def get_ukey(self):
"""检查是否已插入Ukey"""
# res = {"result": False}
# try:
# transport = TSocket.TSocket('localhost', 9000)
# transport = TTransport.TBufferedTransport(transport)
# protocol = TBinaryProtocol.TBinaryProtocol(transport)
# protocol = TMultiplexedProtocol.TMultiplexedProtocol(protocol, "UKeyService")
# client = UKeyServer.Client(protocol)
# transport.open()
#
# logging.info("get ukey transport open success checkUkeyState: %s", client.CheckUkeyState())
# if client.CheckUkeyState() == 1:
# res['result'] = True
# transport.close()
# except Exception as e:
# logging.error("isUkeyPlugin exec error: %s", e)
# transport.close()
#
# return res
client = UkeyClient()
ret = client.is_ukey_plugin()
if ret:
if ret.get("code", -1) == 0:
return get_error_result(data={"result": True})
else:
return ret
else:
return get_error_result("OtherError")
def shutdown_node(self, data):
"""
data : [
{"uuid": "xxxxxxx", "hostname": "xxxxxx"},
{"uuid": "xxxxxxx", "hostname": "xxxxxx"},
{"uuid": "xxxxxxx", "hostname": "xxxxxx"}
]
:param data:
:return:
"""
names = []
ret = get_error_result("Success")
for node in data:
uuid = node.get("uuid")
hostname = node.get("hostname")
names.append(hostname)
obj = self.get_object_by_uuid(YzyNodes, uuid)
if obj:
ret = server_post("/node/shutdown", node)
if ret.get("code", -1) != 0:
logger.error("shutdown node[%s] error: %s" %
(hostname, ret))
break
else:
logger.error("shutdown node[%s] info not exist!" % hostname)
ret = get_error_result("NodeNotExistMsg", hostname=hostname)
msg = "关机节点 %s" % ('/'.join(names))
insert_operation_log(msg, ret["msg"])
return ret
def get_desktop_info(self, request, uuid):
logger.debug("start get instance info")
resp = get_error_result("Success")
try:
node = YzyNodes.objects.filter(deleted=False, uuid=uuid).first()
if not node:
logger.error("get desktop info error: ParameterError")
ret = get_error_result("ParameterError")
return JSONResponse(ret)
resp['data'] = {}
instances = YzyInstances.objects.filter(deleted=False,
host=node).all()
power_instance = instances.filter(
status=constants.STATUS_ACTIVE).count()
error_instance = instances.exclude(message='').count()
resp['data']['node_name'] = node.name
resp['data']['power_instance'] = power_instance
resp['data']['error_instance'] = error_instance
resp['data']['total_instance'] = len(instances)
resp['data']['shutdown_instance'] = len(instances) - power_instance
page = YzyWebPagination()
desktops = page.paginate_queryset(queryset=instances,
request=request,
view=self)
ser = YzyWarningInfoDesktopSerializer(instance=desktops,
many=True,
context={'request': request})
resp['data']['instances'] = ser.data
logger.info("get instance info success: %s", desktops)
return JSONResponse(resp)
except Exception as e:
logger.error("get instance info error:%s", e, exc_info=True)
ret = get_error_result("OtherError")
return JSONResponse(ret)
def reclaim_remote_storage(self, remote_storage_uuid):
ret = server_post("/api/v1/remote_storage/reclaim",
{"remote_storage_uuid": remote_storage_uuid})
if ret.get("code", -1) != 0:
return get_error_result("RemoteStorageReclaimError",
reason=ret.get("msg"))
else:
return get_error_result("Success")
def post(self, request, *args, **kwargs):
username = request.data.get("username", "")
option = request.data.get("option", "")
ret = get_error_result()
user = self.get_object_by_name(username, option)
if user:
ret = get_error_result("AdminUsernameExist")
return JSONResponse(ret)
return JSONResponse(ret)
def post(self, request, *args, **kwargs):
pwd = request.data.get("password", "")
obj = YzyAdminUser.objects.filter(username="******").first()
if not obj or not obj.validate_password(pwd):
logger.error(
"user password check error: %s password check fail!!!" %
"admin")
ret = get_error_result("PasswordCheckError")
return JSONResponse(ret)
return JSONResponse(get_error_result("Success"))
def update_resource_pool(self, pool, data):
try:
pool.name = data["name"]
pool.desc = data["desc"]
pool.save()
except Exception as e:
logger.error("update resource pool:%s failed:%s", pool.uuid, e)
return get_error_result("ResourcePoolUpdateError", name=pool.name)
logger.info("update resource pool:%s success", pool.uuid)
return get_error_result("Success", data=pool)
def get(self, request, *args, **kwargs):
try:
upgrades = YzyTerminalUpgrade.objects.filter(
deleted=False, platform='VOI').order_by("-upload_at")[:10]
ser = YzyTerminalUpgradeSerializer(instance=upgrades,
many=True,
context={'request': request})
return JSONResponse(get_error_result("Success", ser.data))
except Exception as e:
return JSONResponse(get_error_result("OtherError"))
def update_setup_terminal(self, data):
"""更新终端配置
{
"handler": "WebTerminalHandler",
"command": "set_terminal",
"data": {
"mac_list": "00-50-56-C0-00-08,00-50-56-C0-00-07,00-50-56-C0-00-06",
"mode": {
"show_desktop_type": 0,
"auto_desktop": 1,
"open_strategy": true,
"close_desktop_strategy": false,
"close_terminal_strategy": true
},
"program": {
"screen_resolution": "1024*768",
"server_ip": "172.16.1.33",
"show_modify_user_passwd": true,
"terminal_setup_passwd": "111111"
},
"windows": {
"window_mode": 2,
"goto_local_desktop": 5,
"goto_local_auth": true,
"show_local_button": false,
"goto_local_passwd": "123456"
}
}
}
"""
try:
mac_list, name_list = self.get_terminal_mac_name_list(data)
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("ParamError")
setup_info = data.get("setup_info", {})
if not self.check_setup_info(setup_info):
return get_error_result("TerminalSetupInfoParamError")
data = {"mac_list": ",".join(mac_list)}
data.update(setup_info)
req_data = {
"handler": "WebTerminalHandler",
"command": "set_terminal",
"data": data
}
ret = terminal_post("/api/v1/terminal/task", req_data)
msg = "更新终端配置 %s" % "/".join(name_list)
insert_operation_log(msg, ret["msg"])
if ret.get("code", -1) != 0:
logger.error("terminal update setup info fail")
return ret
logger.info("terminal update setup info success!!!")
return get_error_result("Success")
def allocate_remote_storage(self, remote_storage_uuid, resource_pool_uuid):
ret = server_post(
"/api/v1/remote_storage/allocate", {
"remote_storage_uuid": remote_storage_uuid,
'resource_pool_uuid': resource_pool_uuid
})
if ret.get("code", -1) != 0:
return get_error_result("RemoteStorageAllocateError",
reason=ret.get("msg"))
else:
return get_error_result("Success")
def upgrade_terminal(self, data):
""" 终端升级 """
all = data.get("all")
group_uuid = data.get("group_uuid")
upgrade_uuid = data.get("upgrade_uuid")
upgrade = self.get_object_by_uuid(YzyTerminalUpgrade, upgrade_uuid)
if all:
terminals = self.get_all_object(YzyTerminal,
{"group_uuid": group_uuid})
mac_list = list()
name_list = list()
for terminal in terminals:
mac = terminal.mac
if upgrade.platform == terminal.platform:
if mac not in mac_list:
mac_list.append(mac)
name_list.append(terminal.name)
else:
try:
mac_list, name_list = self.get_terminal_mac_name_list(data)
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("ParamError")
terminals = self.get_all_object(YzyTerminal, {"mac": mac_list})
for terminal in terminals:
if terminal.platform.lower() != upgrade.platform.lower():
mac_list.remove(terminal.mac)
if not mac_list:
logger.error("NO need upgrade terminals")
return get_error_result("TerminalUpgradeNotNeedError")
upgrade_pig = upgrade.path
if not os.path.exists(upgrade_pig):
return get_error_result("TerminalUpgradeFileError")
req_data = {
"handler": "WebTerminalHandler",
"command": "update_program",
"data": {
"mac_list": ",".join(mac_list),
"program_file_name": os.path.basename(upgrade_pig)
}
}
ret = terminal_post("/api/v1/terminal/task", req_data)
# msg = "移动终端: %s 到 %s 分组" % ("/".join(name_list), group.name)
# insert_operation_log(msg, ret["msg"])
if ret.get("code", -1) != 0:
logger.error("terminal upgrade error: %s" % ret["msg"])
return ret
logger.info("terminal upgrade success!!! %s" % ("/".join(name_list)))
return get_error_result("Success")
def post(self, request):
terminal_uuid = request.data.get("uuid")
option = request.data.get("option")
if not (terminal_uuid and option):
logger.error("post request error: param error")
return JSONResponse(get_error_result("ParameterError"))
if option == "terminal_hardware":
return self.get_hardware(terminal_uuid)
elif option == "export_resources":
return self.get_terminal_resources(terminal_uuid)
else:
logger.error("option error:%s", option)
return JSONResponse(get_error_result("ParameterError"))
def delete_network(self, uuids):
"""
:param data:
:return:
"""
ret = get_error_result("Success")
success_num = 0
failed_num = 0
try:
for uuid in uuids:
obj = self.get_object_by_uuid(YzyNetworks, uuid)
if obj:
templates = education_model.YzyInstanceTemplate.objects.filter(
deleted=False, network=obj).count()
if templates > 0:
failed_num += 1
continue
groups = education_model.YzyGroup.objects.filter(
deleted=False, network=obj).count()
if groups > 0:
failed_num += 1
continue
desktops = education_model.YzyDesktop.objects.filter(
deleted=False, network=obj).count()
if desktops > 0:
failed_num += 1
continue
personal_desktops = personal_model.YzyPersonalDesktop.objects.filter(
deleted=False, network=obj).count()
if personal_desktops > 0:
failed_num += 1
continue
ret = server_post("/network/delete", {'uuid': uuid})
if ret.get("code", -1) != 0:
failed_num += 1
else:
success_num += 1
else:
failed_num += 1
except Exception as e:
logger.error("delete network failed:%s", e, exc_info=True)
return get_error_result("DataNetworkDeleteFail")
msg = "删除数据网络 %s" % ('/'.join(uuids))
insert_operation_log(msg, ret["msg"])
return get_error_result("Success",
data={
"failed_num": failed_num,
"success_num": success_num
})
def upload_upgrade(self, upgrade_uuid, file_obj):
upgrade = self.get_object_by_uuid(YzyTerminalUpgrade, upgrade_uuid)
if not upgrade:
logger.error("upload upgrade error: %s not exist" % upgrade_uuid)
return get_error_result("ParamError")
file_name = file_obj.name
# 判断文件名称
try:
platform, os_name, version = os.path.splitext(file_name)[0].split(
"_")
if platform.lower() not in ("arm",
"x86") or platform.lower() != str(
upgrade.platform).lower():
raise Exception("platform not in arm or x86")
if os_name.lower() not in ("windows",
"linux") or os_name.lower() != str(
upgrade.os).lower():
raise Exception("os error : %s" % os_name)
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("TerminalUpgradeNameError")
if upgrade.path and os.path.exists(upgrade.path):
os.remove(upgrade.path)
upgrade_dir = constants.TERMINAL_UPGRADE_PATH
if not os.path.exists(upgrade_dir):
try:
os.makedirs(upgrade_dir)
except Exception as e:
logger.error("", exc_info=True)
return get_error_result("OtherError")
file_path = os.path.join(constants.TERMINAL_UPGRADE_PATH, file_name)
# else:
# file_path = upgrade.path
size = 0
with open(file_path, "wb+") as f:
for chunk in file_obj.chunks():
f.write(chunk)
size += len(chunk)
f.close()
# 更新数据库
upgrade.version = version
upgrade.path = file_path
upgrade.size = size_to_M(size)
upgrade.upload_at = datetime.datetime.now()
upgrade.save()
# upgrade.os = os_name
return get_error_result("Success")
def get(self, request, *args, **kwargs):
try:
logger.debug("get_resource_statistic request")
ret = get_error_result("Success")
ret["data"] = {}
node_query_set = YzyNodes.objects.filter(deleted=0).all()
online_node_cnt = len(
[x for x in node_query_set if x.status == "active"])
resource_pool_cnt = YzyResourcePools.objects.filter(
deleted=0).count()
instance_query_set = YzyInstances.objects.filter(deleted=0).all()
online_instance_cnt = len(
[x for x in instance_query_set if x.status == "active"])
terminal_query_set = YzyTerminal.objects.filter(deleted=0).all()
online_terminal_cnt = len(
[x for x in terminal_query_set if x.status == "1"])
ha_info = YzyHaInfo.objects.filter(deleted=False).first()
ret['data']['ha_enable_status'] = 0
if ha_info:
request_data = {"ha_info_uuid": ha_info.uuid}
resp = server_post("/controller/ha_status", request_data)
ret['data']['ha_enable_status'] = resp['data'][
'ha_enable_status']
_time = time.localtime()
ret['data']['current_time'] = time.strftime(
"%Y-%m-%d %H:%M", _time)
ret["data"]["online_node_cnt"] = online_node_cnt
ret["data"]["sum_node_cnt"] = len(node_query_set)
ret["data"]["online_instance_cnt"] = online_instance_cnt
ret["data"]["sum_instance_cnt"] = len(instance_query_set)
ret["data"]["online_terminal_cnt"] = online_terminal_cnt
ret["data"]["sum_terminal_cnt"] = len(terminal_query_set)
ret["data"]["resource_pool_cnt"] = resource_pool_cnt
ret["data"]["alarm_node_cnt"] = 0
ret["data"]["alarm_records_cnt"] = 0
lic_info = LicenseManager().info()
ret["data"]["license_status"] = lic_info['auth_type']
ret["data"]["trail_days"] = lic_info['expire_time']
ret["data"]["vdi_size"] = lic_info['vdi_size']
ret["data"]["voi_size"] = lic_info['voi_size']
ret['data']['current_version'] = 'V' + lic_info['version'].split(
'_')[-2] if lic_info['version'] else '0'
logger.debug("ret: {}".format(ret))
return JSONResponse(ret)
except Exception as err:
logger.error("get_resource_statistic error: %s", err)
logger.error(''.join(traceback.format_exc()))
ret = get_error_result("OtherError")
return JSONResponse(ret)
def post(self, request):
ret = get_error_result()
_data = request.data
_data.update({"enable": 1})
ser = YzyRoleSerializer(data=_data, context={'request': request})
if ser.is_valid():
ser.save()
else:
msg = ser.errors
ret = get_error_result("ParameterError")
ret["msg"] = msg
logger.info("create admin user: %s" % ret)
msg = "创建角色信息: %s" % _data.get("role")
insert_operation_log(msg, ret)
return JSONResponse(ret)
def delete_virtual_switch(self, uuids):
ret = get_error_result("Success")
for uuid in uuids:
obj = self.get_object_by_uuid(YzyVirtualSwitchs, uuid)
if obj:
ret = server_post("/vswitch/delete", {'uuid': uuid})
if ret.get("code", -1) != 0:
logger.error("delete virtual switch [%s] error: %s" %
(uuid, ret))
break
else:
logger.error("delete virtual switch [%s] info not exist!" %
uuid)
ret = get_error_result("VSwitchNotExist")
return ret
def create_remote_storage(self, data):
# 检查nfs服务器的有效性，远端存储名称有效性 等等
ip_addr = data.get('server_ip')
mount_point = data.get('mount_point')
if not is_ip_addr(ip_addr):
return get_error_result("IpAddressError")
out = server_post("/remote_storage/show_mount", {'ip_addr': ip_addr})
if mount_point not in out['data']['mount_list']:
return get_error_result("InvalidNfsServerError")
ret = server_post("/remote_storage/create", data)
if ret.get("code", -1) != 0:
return get_error_result("RemoteStorageAddFail",
reason=ret.get("msg"))
else:
return get_error_result("Success")
def update_name_terminal(self, data):
""" 修改终端名称 """
terminals = data.get("terminals", [])
perfix = data.get("prefix", "")
postfix = data.get("postfix", "")
postfix_start = data.get("postfix_start", "")
use_terminal_id = data.get("use_terminal_id", False)
if not (terminals and perfix and postfix and postfix_start):
logger.error("update terminals name param error")
return get_error_result("ParamError")
name_list = list()
_data = dict()
if use_terminal_id:
for terminal in terminals:
mac = terminal["mac"]
name = terminal["name"]
terminal_id = terminal["terminal_id"]
_s = "%" + "0%sd" % postfix
_n = perfix.upper() + "-" + _s % int(terminal_id)
_data[mac] = _n
if name not in name_list:
name_list.append(name)
else:
for terminal in terminals:
mac = terminal["mac"]
name = terminal["name"]
_s = "%" + "0%sd" % postfix
_n = perfix.upper() + "-" + _s % postfix_start
_data[mac] = _n
postfix_start += 1
if name not in name_list:
name_list.append(name)
req_data = {
"handler": "WebTerminalHandler",
"command": "modify_terminal_name",
"data": _data
}
ret = terminal_post("/api/v1/terminal/task", req_data)
msg = "修改终端名称 %s" % "/".join(name_list)
insert_operation_log(msg, ret["msg"])
if ret.get("code", -1) != 0:
logger.error("terminal update name fail")
return ret
logger.info("terminal update name success!!!")
return get_error_result("Success")
def post(self, request, *args, **kwargs):
# upgrade_package_uuid = request.data.get("upgrade_package_uuid", None)
upgrade_file_obj = request.FILES.get("file", None)
if not upgrade_file_obj:
logger.error("VOI terminal upgrade file upload error")
return JSONResponse(get_error_result("TerminalUpgradeFileError"))
return JSONResponse(voi_terminal_mgr.upload_upgrade(upgrade_file_obj))
def delete_subnet(self, uuids):
"""
data [
{"uuid": "1a870202-3732-11ea-8a2d-000c295dd728","name": "xxxxx"},
{"uuid": "1a870202-3732-11ea-8a2d-000c295dd728","name": "xxxxx"},
{"uuid": "1a870202-3732-11ea-8a2d-000c295dd728","name": "xxxxx"}
]
:param data:
:return:
"""
ret = get_error_result("Success")
# for uuid in uuids:
# obj = self.get_object_by_uuid(YzySubnets, uuid)
# if obj:
# # 判断是否被占用
# templates = YzyInstanceTemplate.objects.filter(subnet_uuid=uuid, deleted=False).all()
# if templates:
# logger.error("delete subnet[%s] error, is be used"% uuid)
ret = server_post("/subnet/delete", {'uuids': uuids})
# if ret.get("code", -1) != 0:
# logger.error("delete subnet[%s] error: %s" % (uuid, ret))
# break
# else:
# logger.error("delete subnet[%s] info not exist!" % uuid)
# ret = get_error_result("SubnetNotExist")
msg = "删除子网 %s" % ('/'.join(uuids))
insert_operation_log(msg, ret["msg"])
return ret
