def post(self, request, *args, **kwargs):
form = UpdateImageFileValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
image_id = form.validated_data.get('image_id')
owner = form.validated_data.get('owner')
name = form.validated_data.get('name')
disk_format = form.validated_data.get('disk_format')
container_format = 'bare'
is_public = form.validated_data.get('is_public')
image_type = form.validated_data.get('image_type')
is_protect = form.validated_data.get('is_protect')
zone = request.data.get('zone')
payload = {
'action': 'UpdateImage',
'image_id': image_id,
'name': name,
'disk_format': disk_format,
'container_format': container_format,
'is_public': is_public,
'image_type': image_type,
'is_protect': is_protect,
'owner': owner,
'zone': zone
}
resp = update_image_file(payload)
return Response(resp)
def post(self, request, *args, **kwargs):
_kwargs = {"data": request.data}
if self.need_request_arg:
_kwargs["request"] = request
# validator的类名一般为View类名+"Validator"
cls_name = self.__class__.__name__ + "Validator"
v_class = getattr(self.validator_module,
cls_name) or self.validator_class
validator = v_class(**_kwargs)
if not validator.is_valid():
err = get_serializer_error(validator.errors)
if isinstance(err, int):
err = self.err_msg_map.get(err)
cres = ConsoleResponse(code=CECode.PARAMETER_ERROR, msg=err)
return self.response(cres)
try:
cres = getattr(validator,
self.validator_method)(validator.validated_data)
except Exception as exp:
if isinstance(exp, ViewExceptionInterface):
msg = self.err_msg_map.get(exp.code)
cres = ConsoleResponse(code=exp.code,
msg=msg,
api_code=exp.api_code,
api_msg=exp.api_msg)
else:
cres = ConsoleResponse(code=CECode.PARAMETER_ERROR)
return self.response(cres)
def post(self, request, *args, **kwargs):
form = GetImageFileValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
code = 0
msg = 'succ'
this_file = request.data.get('image_file')
date = request.data.get('date')
name = request.data.get('name')
owner = form.validated_data.get('owner')
total_size = request.data.get('total_size')
split_size = request.data.get('fileSplitSize')
end_index = request.data.get('index')
md5 = request.data.get('md5')
file_name = owner + '*' + date + '*' + name
real_md5 = get_md5(this_file)
if real_md5 == md5:
with open(os.path.join(MIRRORING_UPLOAD_PATH, file_name), 'a') as destination:
for chunk in this_file.chunks():
destination.write(chunk)
file_ins = UploadFileModel.get_upload_file_by_file_name(file_name)
if file_ins is None:
resp = UploadFileModel.create_upload_file(file_name, total_size, split_size, end_index)
if resp is False:
msg = 'file upload failed! （save to db failed）'
code = 1
else:
file_ins.end_index = end_index
file_ins.save()
return Response(console_response(code, msg, 0, []))
def post(self, request, *args, **kwargs):
form = CheckCaptchaValidator(data=request.data)
if not form.is_valid():
return Response({
"code": 1,
"msg": get_serializer_error(form.errors),
"data": {}
})
return Response({"code": 0, "msg": "succ", "data": {}})
def post(self, request, *args, **kwargs):
form = DescribePhysicalMachineIPMIAddrValidator(data=request.data)
if not form.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(form.errors)))
physical_machine_id = form.validated_data['physical_machine_id']
resp = describe_physical_machine_IPMIAddr(id=physical_machine_id)
return Response(resp)
def post(self, request, *args, **kwargs):
check_identifier_validator = CheckIdentifierValidator(
data=request.data)
if not check_identifier_validator.is_valid():
return Response({
"code":
1,
"msg":
get_serializer_error(check_identifier_validator.errors),
"data": {}
})
return Response({"code": 0, "msg": "succ", "data": {}})
def post(self, request, *args, **kwargs):
validator = ChangeCellPhoneValidator(data=request.data,
request=request,
redis_conn=account_redis_api)
if not validator.is_valid():
return Response(
console_response(code=1,
ret_msg=get_serializer_error(
validator.errors)))
_update = {'phone': validator.validated_data["cell_phone"]}
AccountService.update(request.user.account, _update)
return Response(console_response())
def post(self, request, *args, **kwargs):
form = HaltPhysicalMachineValidator(data=request.data)
if not form.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(form.errors)))
physical_machine_hostname = form.validated_data[
'physical_machine_hostname']
resp = halt_physical_machine(hostname=physical_machine_hostname)
return Response(console_response(code=resp.get("code")))
def post(self, request, *args, **kwargs):
validator = ChangePasswordValidator(data=request.data,
user=request.user)
if not validator.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
validator.errors)),
status=status.HTTP_200_OK)
new_password = validator.validated_data.get("new_password")
request.user.set_password(new_password)
request.user.save()
return Response(console_response(code=0), status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = DescribePhysicalMachineBaseInfoValidator(data=request.data)
if not form.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(form.errors)))
physical_machine_hostname = form.validated_data[
'physical_machine_hostname']
resp = describe_physical_machine_baseinfo(
hostname=physical_machine_hostname)
return Response(resp)
def post(self, request, *args, **kwargs):
validator = DisperseVirtualMachineValidator(data=request.data)
if not validator.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(validator.errors)))
src_physical_machine = validator.validated_data["src_physical_machine"]
ret = disperse_virtual_machine(src_physical_machine)
if ret != 0:
return Response(console_response(code=1))
return Response(console_response(code=0))
def post(self, request, *args, **kwargs):
form = DescribeImagesListValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
host_list = InstancesModel.objects.filter(deleted=False).values()
for I in host_list:
I.update(
{"pub_subnet": has_joined_ext_network(I.get("instance_id"))})
return Response(console_response(0, 'succ', len(host_list), host_list))
def post(self, request, *args, **kwargs):
data = request.data
check_code_validator = CheckCodeValidator(data=data,
request=request,
redis_conn=account_redis_api)
if not check_code_validator.is_valid():
return Response({
"code":
1,
"msg":
get_serializer_error(check_code_validator.errors),
"data": {}
})
return Response({"code": 0, "msg": "succ", "data": {}})
def post(self, request, *args, **kwargs):
"""
发送用户手机验证码
"""
data = request.data
code_type_validator = CodeTypeValidator(data=data)
if not code_type_validator.is_valid():
return Response({
"code":
1,
"msg":
get_serializer_error(code_type_validator.errors),
"data": {}
})
code_type = code_type_validator.validated_data["code_type"]
if code_type == "dynamic_code":
validator = SendDynamicCodeValidator(data=data)
else:
validator = SendVerifyCodeValidator(data=data)
if not validator.is_valid():
logger.debug("+++++" * 10)
logger.error(get_serializer_error(validator.errors))
return Response({
"code": 1,
"msg": get_serializer_error(validator.errors),
"data": {},
"ret_code": 90001
})
code_type = validator.validated_data["code_type"]
cell_phone = validator.validated_data["cell_phone"]
send_code = SendCodeApi(code_type=code_type,
cell_phone=cell_phone,
redis_conn=account_redis_api)
result, error = send_code.send_msg()
logger.debug("Send Code Result: %s" % (error or "succ"))
resp = {"code": 0 if result else 1, "msg": error if error else "succ"}
return Response(resp)
def post(self, request, *args, **kwargs):
validator = MigrateVirtualMachineValidator(data=request.data)
if not validator.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(validator.errors)))
instance_id = validator.validated_data["instance_id"]
dst_physical_machine = validator.validated_data["dst_physical_machine"]
ret = migrate_virtual_machine(instance_id, dst_physical_machine)
if ret != 0:
return Response(console_response(code=1))
return Response(console_response(code=0))
def post(self, request, *args, **kwargs):
validator = LoginUserInfoValidator(data=request.data)
if not validator.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(validator.errors)))
nickname = validator.validated_data.get("nickname")
name = validator.validated_data.get("name")
company = validator.validated_data.get("company")
account = AccountService.change_user_info(user=request.user,
nickname=nickname,
name=name,
company=company)
serializer = AccountSerializer(account)
return Response(console_response(ret_set=[serializer.data]))
def post(self, request, *args, **kwargs):
validator = DescribePhysicalMachineVmamountValidator(data=request.data)
if not validator.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(validator.errors)))
physical_machine_hostname = validator.validated_data[
'physical_machine_hostname']
vm_amount = describe_physical_machine_vm_amount(
hostname=physical_machine_hostname)
return Response(
console_response(ret_code=0,
total_count=1,
ret_set={"vm_amount": vm_amount}))
def post(self, request, *args, **kwargs):
form = ClearGatewayValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"router_id": form.validated_data.get("router_id")
}
resp = RouterService.clear_gateway(payload)
return Response(resp)
def post(self, request, *args, **kwargs):
form = DeleteImageListValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"image_id": form.validated_data.get("image_id"),
"action": "DeleteImage"
}
resp = delete_image_by_admin(payload)
return Response(resp)
def post(self, request, *args, **kwargs):
form = DescribeRecordsValidator(data=request.data)
if not form.is_valid():
return Response(
console_response(
code=1,
msg=get_serializer_error(form.errors),
))
resp = ConsoleRecord.query_record(request.data)
if resp["code"] == 0:
data = RecordsSerializer(resp["data"]["data"], many=True)
return Response(
console_response(code=0,
total_count=resp["data"]["total_count"],
ret_set=data.data))
return Response(console_response(code=1, msg=resp["msg"]))
def post(self, request, *args, **kwargs):
form = DescribeImagesListValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"action": "ShowImage",
"image_id": request.data.get("image_id")
}
output_list = show_image_by_admin(payload)
handle = HandleList()
return Response(handle.handle(request, output_list))
def post(self, request, *args, **kwargs):
form = JudgeImageFileExistValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
resp = []
date = request.data.get('date')
name = request.data.get('name')
owner = form.validated_data.get('owner')
file_name = owner + '*' + date + '*' + name
file_ins = UploadFileModel.get_upload_file_by_file_name(file_name)
if file_ins is not None:
resp.append({
'index': file_ins.end_index,
'fileSplitSize': file_ins.split_size
})
return Response(console_response(0, "succ", len(resp), resp))
def post(self, request, *args, **kwargs):
form = DeleteImageFileValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(form.errors)),
status=status.HTTP_200_OK)
image_id = form.validated_data.get('image_id')
owner = form.validated_data.get('owner')
file_name = ImageFileModel.get_file_name_by_image_id(image_id)
zone = request.data.get('zone')
payload = {
'action': 'DeleteImage',
'image_id': image_id,
'file_name': file_name,
'owner': owner,
'zone': zone
}
resp = delete_image_file(payload)
return Response(resp)
def post(self, request, *args, **kwargs):
form = DeleteSubnetValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
subnet_list = request.data.get("subnet_list")
for S in subnet_list:
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"name": S.get("name"),
"subnet_id": S.get("subnet_id"),
"network_id": S.get("network_id"),
}
resp = SubnetService.delete_subnet(request, payload)
return Response(console_response())
def post(self, request, *args, **kwargs):
validator = DescribePhysicalMachineHostnameListValidator(
data=request.data)
if not validator.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(validator.errors)))
pool_name = validator.validated_data["pool_name"]
vm_type = validator.validated_data["VM_type"]
total_count, hostname_list = describe_physical_machine_hostname_list(
pool_name=pool_name, vm_type=vm_type)
if total_count == 0:
return Response(console_response(ret_code=0))
return Response(
console_response(ret_code=0,
total_count=total_count,
ret_set=hostname_list))
def post(self, request, *args, **kwargs):
form = CreateRouterValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"name": form.validated_data.get("name"),
"enable_snat": form.validated_data.get("enable_snat"),
"enable_gateway": form.validated_data.get("enable_gateway"),
"subnet_list": form.validated_data.get("subnet_list")
}
resp = RouterService.create_router(payload)
return Response(resp)
def post(self, request, *args, **kwargs):
form = DescribeRouterValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"subnet_id": form.validated_data.get("subnet_id"),
"router_id": form.validated_data.get("router_id")
}
resp = RouterService.describe_router(payload)
if resp.get("code"):
return Response(resp)
output_list = resp.get('ret_set')
handle = HandleList()
return Response(handle.handle(request, output_list))
def post(self, request, *args, **kwargs):
form = DescribeRouterValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"name": form.validated_data.get("name"),
}
subnet_name = form.validated_data.get("subnet_name")
if subnet_name:
payload.update({"subnet_name": subnet_name})
output_list = SubnetService.describe_subnet(payload)
handle = HandleList()
return Response(handle.handle(request, output_list))
def post(self, request, *args, **kwargs):
form = UpdateSubnetValidator(data=request.data)
if not form.is_valid():
return Response(console_response(code=1,
ret_msg=get_serializer_error(
form.errors)),
status=status.HTTP_200_OK)
payload = {
"owner": form.validated_data.get("owner"),
"zone": form.validated_data.get("zone"),
"name": form.validated_data.get("name"),
"subnet_name": form.validated_data.get("subnet_name"),
"subnet_id": form.validated_data.get("subnet_id"),
"network_id": form.validated_data.get("network_id"),
"allocation_pools": request.data.get("allocation_pools"),
"public": form.validated_data.get("public"),
"user_list": request.data.get("user_list"),
}
resp = SubnetService.update_subnet(request, payload)
return Response(resp)
def post(self, request, *args, **kwargs):
form = DescribePhysicalMachineResourceUsageValidator(data=request.data)
if not form.is_valid():
return Response(
console_response(code=1,
msg=get_serializer_error(form.errors)))
physical_machine_hostname = form.validated_data[
'physical_machine_hostname']
_resource_type = form.validated_data['resource_type']
if "time_range" in form.validated_data:
_time_range = form.validated_data['time_range']
resp = describe_physical_machine_resource_usage(
hostname=physical_machine_hostname,
resource_type=_resource_type,
time_range=_time_range)
else:
resp = describe_physical_machine_resource_usage(
hostname=physical_machine_hostname,
resource_type=_resource_type)
return Response(
console_response(ret_code=resp.get("code"),
ret_set=resp.get("ret_set")))
