def post(self, request, *args, **kwargs):
form = AllocateIpsSerializer(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
data = form.validated_data
count = data.pop("count")
payload = Payload(request=request,
action='AllocateIP',
bandwidth=data.get("bandwidth"),
billing_mode=data.get("billing_mode", "bandwidth"),
ip_name=data.get("ip_name"),
charge_mode=data.get("charge_mode"),
package_size=data.get("package_size"),
count=count)
if data.get("ip"):
payload = Payload(request=request,
action='AllocateIP',
bandwidth=data.get("bandwidth"),
billing_mode=data.get("billing_mode",
"bandwidth"),
ip_name=data.get("ip_name"),
floatingip=data.get("ip_address"),
charge_mode=data.get("charge_mode"),
package_size=data.get("package_size"),
count=count)
resp = allocate_ips(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = CreateLoadbalancerSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
use_basenet = validator.validated_data.get("use_basenet")
lb_name = validator.validated_data.get("lb_name")
net_id = validator.validated_data.get("net_id")
ip_id = validator.validated_data.get("ip_id")
package_size = validator.validated_data.get("package_size")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"use_basenet": use_basenet,
"lb_name": lb_name,
"net_id": net_id,
"ip_id": ip_id,
"package_size": package_size
}
resp = create_loadbalancer(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = DescribeIpsSerializer(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
ip_ids = form.validated_data.get("ip_ids")
subnet_name = form.validated_data.get("subnet_name")
page_index = form.validated_data.get("page_index")
page_size = form.validated_data.get("page_size")
payload = Payload(
request=request,
action='DescribeIP',
)
if ip_ids is not None:
payload = Payload(
request=request,
action='DescribeIP',
ip_id=ip_ids,
)
if subnet_name:
payload = Payload(request=request,
action="DescribeIP",
subnet_name=subnet_name,
page_index=page_index,
page_size=page_size)
resp = describe_ips(payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = CreateLoadbalancerMemberSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get("lb_id")
lbl_id = validator.validated_data.get("lbl_id")
instance_id = validator.validated_data.get("instance_id")
# ip_address = validator.validated_data.get("ip_address")
port = validator.validated_data.get("port")
weight = validator.validated_data.get("weight")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"lb_id": lb_id,
"lbl_id": lbl_id,
"instance_id": instance_id,
# "ip_address": ip_address,
"protocol_port": port,
"weight": weight
}
resp = create_loadbalancer_member(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = ReleaseIpsSerializer(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
ips = form.validated_data.get("ips")
payload = Payload(request=request, action='UnBindIP', ips=ips)
resp = release_ip(payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
data = request.data
validator = DeleteRoutersSerializer(data=data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
routers = validator.validated_data.get("routers")
payload = Payload(request=request, action=self.action, routers=routers)
resp = delete_routers(payload.dumps())
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = CreateNetValidator(data=request.data)
if not form.is_valid():
logger.error(form.errors)
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
data = form.validated_data
zone = request.zone
owner = request.owner
type = data.get("net_type")
cidr = data.get("cidr")
gateway_ip = data.get("gateway_ip")
# valid gateway_ip: public - need gateway_ip; private - donot need
code, msg = net_gateway_ip_validator(gateway_ip, type)
if code:
return Response(console_response(code=code, msg=msg))
# valid net type cidr
code, msg = net_type_cidr_validator(cidr, type)
if code:
return Response(console_response(code=code, msg=msg))
# first according to net_type get the network_uuid, if get none do create networks action
networks = NetworksModel.get_networks_by_zone_owner_and_type(
zone, owner, type)
net_type = self.network_type.get(type, "vxlan")
if not networks:
action = "CreateNetwork"
network_uuid, err = create_network(payload=Payload(
request=request, action=action, type=net_type).dumps())
if not network_uuid:
logger.error("CreateNetwork error, %s" % str(err))
return Response(
console_response(code=ErrorCode.net.GET_NETWORK_FAILED,
msg=err))
else:
network_uuid = networks.uuid
# do action
payload = Payload(
request=request,
action=self.action,
network_uuid=network_uuid,
cidr=data.get("cidr"),
net_name=data.get("net_name"),
gateway_ip=data.get("gateway_ip"),
net_type=net_type,
ip_version=data.get("ip_version"),
allocation_pools_start=data.get("allocation_pools_start"),
allocation_pools_end=data.get("allocation_pools_end"),
enable_dhcp=data.get("enable_dhcp"))
resp = create_net(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = TrashLoadbalancerSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get('lb_id')
resp = trash_loadbalancer(lb_id)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = ModifyIpsNameSerializer(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
ip_id = form.validated_data.get("ip_id")
payload = Payload(request=request,
action="ModifyIpsName",
ip_name=form.validated_data.get("ip_name"),
ip_id=ip_id)
resp = modify_ip_name(payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
data = request.data
validator = ClearRouterGatewaySerializer(data=data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
router_id = validator.validated_data.get("router_id")
payload = Payload(request=request,
action=self.action,
router_id=router_id)
resp = disable_gateway(payload.dumps())
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = LeaveBaseNetValidator(data=request.data)
if not form.is_valid():
logger.error(form.errors)
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
data = form.validated_data
payload = Payload(request=request,
action=self.action,
instance_id=data.get("instance_id"))
resp = leave_base_net(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
form = DescribeNetValidator(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
payload = Payload(request=request,
action='DescribePubilcIPPool',
ext_net=True)
resp = describe_pub_nets(payload=payload.dumps())
if resp.get("ret_code"):
return Response(resp)
return Response(resp)
def post(self, request, *args, **kwargs):
data = request.data
validator = JoinRouterSerializer(data=data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
router_id = validator.validated_data.get("router_id")
payload = Payload(request=request,
action=self.action,
subnets=data.get("nets"),
router_id=router_id)
resp = join_router(payload.dumps())
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = ClearGatewaySerializer(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
router_name = form.validated_data.get("router_name")
payload = Payload(
request=request,
action=self.action,
router_name=router_name,
)
resp = api_router(payload.dumps())
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = DescribeNetInstancesValidator(data=request.data)
if not form.is_valid():
logger.error(form.errors)
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
data = form.validated_data
# do action
payload = Payload(request=request,
action=self.action,
net_id=data.get("net_id"))
resp = describe_net_instances(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = DeleteRouterSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
data = validator.validated_data
payload = Payload(
request=request,
action=self.action,
router_name=data.get("router_name"),
)
resp = api_router(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = CreateRouterSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
data = validator.validated_data
payload = Payload(request=request,
action=self.action,
name=data.get("name"),
enable_gateway=data.get("enable_gateway"),
admin_state_up=data.get("admin_state_up"),
enable_snat=data.get("enable_snat"))
resp = api_router(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
data = request.data
validator = DescribeRoutersSerializer(data=data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg))
router_id = validator.validated_data.get("router_id")
payload = Payload(request=request, action=self.action)
if router_id is not None:
payload = Payload(
request=request,
action=self.action,
router_id=router_id,
)
resp = describe_routers(payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = JoinableLoadbalancerResourceSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get("lb_id")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"lb_id": lb_id,
}
resp = joinable_loadbalancer_resource(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = ModifyNetValidator(data=request.data)
if not form.is_valid():
logger.error(form.errors)
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
data = form.validated_data
# do action
payload = Payload(request=request,
action=self.action,
net_id=data.get("net_id"),
net_name=data.get("net_name"),
gateway_ip=data.get("gateway_ip"),
enable_dhcp=data.get('enable_dhcp'))
resp = modify_net(payload=payload.dumps())
return Response(resp)
def post(self, request, *args, **kwargs):
validator = UpdateLoadbalancerListenerSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get("lb_id")
lbl_id = validator.validated_data.get("lbl_id")
lbl_name = validator.validated_data.get("lbl_name")
protocol = validator.validated_data.get("protocol")
protocol_port = validator.validated_data.get("protocol_port")
lb_algorithm = validator.validated_data.get("lb_algorithm")
health_check_type = validator.validated_data.get("health_check_type")
health_check_delay = validator.validated_data.get("health_check_delay")
health_check_timeout = validator.validated_data.get("health_check_timeout")
health_check_max_retries = validator.validated_data.get("health_check_max_retries")
session_persistence_type = validator.validated_data.get("session_persistence_type")
health_check_url_path = validator.validated_data.get("health_check_url_path", None)
health_check_expected_codes = validator.validated_data.get("health_check_expected_codes", None)
cookie_name = validator.validated_data.get("cookie_name", None)
payload = {
"owner": request.owner,
"zone": request.zone,
"lb_id": lb_id,
"lbl_id": lbl_id,
"lbl_name": lbl_name,
"protocol": protocol,
"protocol_port": protocol_port,
"lb_algorithm": lb_algorithm,
"health_check_type": health_check_type,
"health_check_delay": health_check_delay,
"health_check_timeout": health_check_timeout,
"health_check_max_retries": health_check_max_retries,
"session_persistence_type": session_persistence_type,
"health_check_url_path": health_check_url_path,
"health_check_expected_codes": health_check_expected_codes,
"cookie_name": cookie_name,
}
resp = update_loadbalancer_listener(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
validator = DescribeLoadbalancersSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get("lb_id")
features = validator.validated_data.get("features")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"lb_id": lb_id,
"features": features
}
resp = describe_loadbalancers(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
"""
"""
validator = CreateRoutersSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code, msg=msg),
status=status.HTTP_200_OK)
# do create action
data = validator.validated_data
payload = Payload(request=request,
action=self.action,
count=data.get("count"),
name=data.get("router_name"),
enable_gateway=data.get("enable_gateway"),
enable_snat=data.get("enable_gateway"))
resp = create_routers(payload=payload.dumps())
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
validator = DescribeLoadbalancerMonitorSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
resource_type = validator.validated_data.get("resource_type")
resource_id = validator.validated_data.get("resource_id")
data_fmt = validator.validated_data.get("data_fmt")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"resource_type": resource_type,
"resource_id": resource_id,
"data_fmt": data_fmt,
}
resp = describe_loadbalancer_monitor(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
validator = UpdateLoadbalancerMemberSerializer(data=request.data)
if not validator.is_valid():
code, msg = console_code(validator)
return Response(console_response(code=code,
msg=msg),
status=status.HTTP_200_OK)
lb_id = validator.validated_data.get("lb_id")
lbl_id = validator.validated_data.get("lbl_id")
lbm_id = validator.validated_data.get("lbm_id")
weight = validator.validated_data.get("weight")
payload = {
"owner": request.owner,
"zone": request.zone,
"action": self.action,
"lb_id": lb_id,
"lbl_id": lbl_id,
"lbm_id": lbm_id,
"weight": weight
}
resp = update_loadbalancer_member(payload)
return Response(resp, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
form = DescribeNetValidator(data=request.data)
if not form.is_valid():
code, msg = console_code(form)
return Response(console_response(code=code, msg=msg))
subnet_type = form.validated_data.get("subnet_type", "KVM")
if subnet_type == 'POWERVM':
# POWERVM 暂时不支持router功能
fields = form.validated_data.get("fields", "instance")
else:
fields = form.validated_data.get("fields", "router,instance")
payload = Payload(request=request,
action='DescribeNets',
subnet_id=form.validated_data.get("id"),
name=form.validated_data.get("owner"),
fields=fields,
subnet_type=subnet_type,
filter_by_owner=True,
page_index=form.validated_data.get("page_index"),
page_size=form.validated_data.get("page_size"))
resp = describe_nets(payload=payload.dumps())
return Response(resp)
