def modify_net(payload):
NetsModel.update_nets_model()
net_id = payload.pop("net_id")
net_name = payload.pop("net_name")
payload.update({"subnet_id": net_id})
payload.update({"name": net_name})
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.post(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp["data"].get('ret_code', -1)
api_status = resp['api_status']
if code != Code.OK:
logger.error(
"ModifyNet error: api_ret_code (%d), api_status (%d), msg (%s)" %
(api_code, api_status, msg))
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
net_info = resp["data"]["ret_set"][0]
net_info = filter_needed_net_info(net_info)
return console_response(code=Code.OK,
msg=msg,
total_count=len(net_info),
ret_set=net_info)
def describe_listener_by_id(payload):
"""
{
'admin_state_up': True,
'connection_limit': -1,
'default_pool_id': '93873e55-647d-43fd-86ca-b5e63012759b',
'default_tls_container_id': None,
'description': '',
'id': 'ec25dbbc-3d3b-4196-b2f8-2868a3c5d1a1',
'loadbalancers': [{'id': 'cb40c835-6d00-4fd6-8b7b-b8152c5227a0'}],
'name': 'lbl-9cxezd2h',
'protocol': 'TCP',
'protocol_port': 22,
'sni_container_ids': [],
'tenant_id': '114899e0545b43b6a389b7bc2cb5fe34'
}
"""
lb = LoadbalancerModel.get_lb_by_id(payload.pop("lb_id"))
lbl = ListenersModel.get_lbl_by_id(payload.pop("lbl_id"))
resp = describe_listener_api(payload,
loadbalancer_id=lb.uuid,
listener_id=lbl.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
else:
info = resp['data']['ret_set'].pop()
return console_response(code=Code.OK,
msg=msg,
total_count=1,
ret_set=info)
def describe_net_instances(payload):
"""
Describe net instances
"""
NetsModel.update_nets_model()
net_id = payload.pop("net_id", None)
inst = NetsModel.get_net_by_id(net_id)
uuid = inst.uuid
payload.update({"subnet_id": uuid})
# call api
# resp = api.get(payload=payload, timeout=10)
resp = api.get(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp["data"].get('ret_code', -1)
if code != 0:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
instance_set = resp["data"].get("ret_set", [])
instance_list = []
for n in instance_set:
instance_list.append(n)
resp["data"]["ret_set"] = instance_list
resp["data"]["total_count"] = len(resp["data"]["ret_set"])
return console_response(code=Code.OK,
total_count=len(instance_set),
ret_set=instance_set)
def bind_loadbalancer_ip(payload):
ip_id = payload.pop("ip_id")
lb_id = payload.pop("lb_id")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
ip = IpsModel.get_ip_by_id(ip_id)
# call describe_loadbalancer api
resp = describe_loadbalancers_api(payload, loadbalancer_id=lb.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
lb_set = resp.get("data", {}).get("ret_set", [])
port_id = None
fip_info = None
if lb_set:
port_id = lb_set[0].get("vip_port_id")
fip_info = lb_set[0]["fip_info"]
if not port_id:
msg = "Lb(%s) get port_id error" % lb_id
logger.error(msg)
return console_response(code=LoadBalancerErrorCode, msg=msg)
if fip_info:
msg = "Lb(%s) had bind fip(%s)" % (lb_id, fip_info["ip_address"])
logger.error(msg)
return console_response(code=LoadBalancerErrorCode.BIND_IP_REPEATED,
msg=msg)
resp = bind_ip_api(payload, port_id, ip.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
return console_response()
def describe_pub_nets(payload):
resp = api.get(payload=payload)
code = resp["code"]
msg = resp["msg"]
api_code = resp["data"].get("ret_code", -1)
api_status = resp['api_status']
if code != Code.OK:
code = convert_api_code(api_code)
logger.error(
"DescribeNets error: api_ret_code (%d), api_status (%d), msg (%s)"
% (api_code, api_status, msg))
return console_response(code=code, msg=msg)
net_set = resp["data"].get("ret_set", [])
subnet_set = []
for net in net_set:
net_id = net.get("id")
total_ips = net.get("total_ips")
used_ips = net.get("used_ips")
ip_pool = IpPoolModel.get_ip_pool_by_uuid(net_id)
if ip_pool is None:
logger.error("get ip_pool from database failed")
continue
# ip_pool_id = ip_pool.ip_pool_id
line = ip_pool.line
bandwidth = ip_pool.bandwidth
if total_ips > used_ips:
status = "available"
else:
status = "exhaust"
for subnet in net.get('subnets', []):
subnet_set.append({
"id": subnet.get("subnet_id"),
"name": subnet.get("subnet_name"),
"cidr": subnet.get("cidr"),
"ip_pool_id": subnet.get("subnet_name"),
"status": status,
"allocated_count": subnet.get("used_ips"),
"line": line,
"bandwidth": bandwidth,
"total_ips": subnet.get("total_ips"),
"subnets": [subnet]
})
return console_response(code=Code.OK,
msg=msg,
total_count=len(subnet_set),
ret_set=subnet_set)
def unbind_loadbalancer_ip(payload):
ip_id = payload.pop("ip_id")
ip = IpsModel.get_ip_by_id(ip_id)
resp = unbind_ip_api(payload, ip.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
return console_response()
def delete_loadbalancer(payload):
zone = payload.get("zone")
owner = payload.get("owner")
lb_id = payload.pop("lb_id")
deleted = payload.pop('deleted', False)
lb = LoadbalancerModel.get_lb_by_id(lb_id, deleted=deleted)
# step 0 delete listener
lbl_list = ListenersModel.get_lbl_by_lb_id(lb_id)
for lbl in lbl_list:
ret_res = delete_loadbalancer_listener({
"zone": zone,
"owner": owner,
"lb_id": lb_id,
"lbl_id": lbl.lbl_id
})
if ret_res.get("ret_code") != 0:
return ret_res
# TODO: need UnbindIP or not
# step 1 delete loadbalancer
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
resp = delete_loadbalancer_api(payload, lb.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
flag, err = LoadbalancerModel.delete_lb(lb_id)
if not flag:
logger.error("Delete LB %s from database error: %s" % (lb_id, err))
return console_response(code=LoadBalancerErrorCode.DELETE_LB_ERROR,
msg=str(err))
code, msg = Code.OK, "succ"
return console_response(code=code, msg=msg, total_count=1, ret_set=[lb_id])
def describe_loadbalancer_monitor(payload):
resource_type = payload.pop("resource_type")
resource_id = payload.pop("resource_id")
data_fmt = payload.pop("data_fmt")
time_stamp = int(time.time())
if resource_type == RESOURCE_TYPE.loadbalancer:
listeners = ListenersModel.get_lbl_by_lb_id(resource_id)
resource_ids = []
for l in listeners:
resource_ids.append(l.uuid)
if resource_ids:
resp = describe_monitor_bandwidth_api(payload, resource_ids,
RESOURCE_TYPE.listener,
time_stamp, data_fmt)
else:
if resource_type == RESOURCE_TYPE.listener:
resource = ListenersModel.get_lbl_by_id(resource_id)
protocol = resource.protocol
elif resource_type == RESOURCE_TYPE.member:
resource = MembersModel.get_lbm_by_id(resource_id)
protocol = resource.listener.protocol
items = MONITOR_ITEMS.get(resource_type).get(protocol)
resp = describe_monitor_data_api(payload, resource.uuid, resource_type,
time_stamp, data_fmt, items)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
monitor_data = resp.get("data", {}).get("ret_set", [])[0]
time_stamp = monitor_data.get("timestamp")
monitor_data.update({"timestamp": time_stamp, "resource_id": resource_id})
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=monitor_data)
def delete_loadbalancer_member(payload):
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
lbm_id = payload.pop("lbm_id")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lbl = ListenersModel.get_lbl_by_id(lbl_id)
pool = lbl.pool
lbm = MembersModel.get_lbm_by_id(lbm_id)
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# call backend
resp_delete_member = delete_pool_member_api(payload, pool.uuid, lbm.uuid)
api_code = resp_delete_member.get("data", {}).get("ret_code")
code = resp_delete_member.get("code", -1)
msg = resp_delete_member.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
# delete member from database
flag, err = MembersModel.delete_lbm(lbm_id)
if not flag:
logger.error("Delete Member %s from database error: %s" %
(lbl_id, err))
return console_response(code=LoadBalancerErrorCode.DELETE_MEMBER_ERROR,
msg=str(err))
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbm_id])
def update_loadbalancer_member(payload):
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
lbm_id = payload.pop("lbm_id")
weight = payload.pop("weight")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lbl = ListenersModel.get_lbl_by_id(lbl_id)
pool = lbl.pool
lbm = MembersModel.get_lbm_by_id(lbm_id)
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# call backend
resp_update_member = update_pool_member_api(payload, pool.uuid, lbm.uuid,
weight)
api_code = resp_update_member.get("data", {}).get("ret_code")
code = resp_update_member.get("code", -1)
msg = resp_update_member.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
# save member weight
lbm.weight = weight
lbm.save()
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbm_id])
def create_loadbalancer_member(payload):
zone = payload.get("zone")
owner = payload.get("owner")
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
instance_id = payload.pop("instance_id")
# ip_address = payload.pop("ip_address")
protocol_port = payload.pop("protocol_port")
weight = payload.pop("weight")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lbl = ListenersModel.get_lbl_by_id(lbl_id)
pool = lbl.pool
instance = InstancesModel.get_instance_by_id(instance_id)
subnet_id = lb.net_id if not lb.is_basenet else None
# get member address from backend
is_basenet = lb.is_basenet
net_id = None
if not is_basenet:
net_id = lb.net_id
instance_info = get_instances_info(owner,
zone,
is_basenet,
net_id,
instance_uuid=instance.uuid)
if instance_info:
ip_address = instance_info[0]["resource_addr"]
else:
msg = "%s IP addr NOT found" % instance_id
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.INSTANCE_IP_ADDR_NOT_FOUND, msg=msg)
# check address and port is legal or not
if MembersModel.lbm_exists_by_address_and_port(lbl, ip_address,
protocol_port):
msg = "%s:%d already EXISTED" % (ip_address, protocol_port)
logger.error(msg)
return console_response(code=LoadBalancerErrorCode.LB_MEMBER_EXISTED,
msg=msg)
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# call backend
resp_create_member = create_pool_member_api(payload,
pool.uuid,
lb.is_basenet,
ip_address,
protocol_port,
weight,
subnet_id=subnet_id)
api_code = resp_create_member.get("data", {}).get("ret_code")
code = resp_create_member.get("code", -1)
msg = resp_create_member.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
ret_member = resp_create_member.get("data", {}).get("ret_set", [{}])[0]
if not ret_member:
msg = "Create Member Error from Backend"
logger.error(msg)
return console_response(code=LoadBalancerErrorCode.CREATE_MEMBER_ERROR,
msg=msg)
member_uuid = ret_member.get("id")
# save member
lbm_id = make_lbm_id()
lbl, err = save_lb_member(zone, owner, lbm_id, member_uuid, lbl_id,
instance_id, ip_address, protocol_port, weight)
if err:
logger.error("Save LB Member %s from database error: %s" %
(lbm_id, err))
return console_response(
code=LoadBalancerErrorCode.SAVE_LB_MEMBER_ERROR, msg=str(err))
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbm_id])
def delete_loadbalancer_listener(payload):
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lbl = ListenersModel.get_lbl_by_id(lbl_id)
pool = lbl.pool
healthmonitor = pool.healthmonitor
# step 0 delete healthmonitor
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# delete by backend api
resp_delete_healthmonitor = delete_healthmonitor_api(
payload, healthmonitor.uuid)
api_code0 = resp_delete_healthmonitor.get("data", {}).get("ret_code")
code0 = resp_delete_healthmonitor.get("code", -1)
msg0 = resp_delete_healthmonitor.get("msg", "failed")
if code0 != Code.OK:
code0 = convert_api_code(api_code0)
return console_response(code=code0, msg=msg0)
# delete healthmonitor in database
flag, err = HealthMonitorsModel.delete_lbhm(healthmonitor.lbhm_id)
if not flag:
logger.error("Delete Healthmonitor %s from database error: %s" %
(healthmonitor.lbhm_id, err))
return console_response(
code=LoadBalancerErrorCode.DELETE_HEALTHMONITOR_ERROR,
msg=str(err))
# step 1 delete pool
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# delete by backend api
resp_delete_pool = delete_pool_api(payload, pool.uuid)
api_code1 = resp_delete_pool.get("data", {}).get("ret_code")
code1 = resp_delete_pool.get("code", -1)
msg1 = resp_delete_pool.get("msg", "failed")
if code1 != Code.OK:
code1 = convert_api_code(api_code1)
return console_response(code=code1, msg=msg1)
# delete member in database
lbm_list = MembersModel.get_lbm_by_lbl_id(lbl_id)
for lbm in lbm_list:
flag, err = MembersModel.delete_lbm(lbm.lbm_id)
if not flag:
logger.error("Delete Member %s from database error: %s" %
(lbm.lbm_id, err))
return console_response(
code=LoadBalancerErrorCode.DELETE_MEMBER_ERROR, msg=str(err))
# delete pool in database
flag, err = PoolsModel.delete_lbp(pool.lbp_id)
if not flag:
logger.error("Delete Pool %s from database error: %s" %
(pool.lbp_id, err))
return console_response(code=LoadBalancerErrorCode.DELETE_POOL_ERROR,
msg=str(err))
# step 2 delete listener
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# delete by backend api
resp_delete_listener = delete_listener_api(payload, lbl.uuid)
api_code2 = resp_delete_listener.get("data", {}).get("ret_code")
code2 = resp_delete_listener.get("code", -1)
msg2 = resp_delete_listener.get("msg", "failed")
if code2 != Code.OK:
code2 = convert_api_code(api_code2)
return console_response(code=code2, msg=msg2)
# delete in database
flag, err = ListenersModel.delete_lbl(lbl_id)
if not flag:
logger.error("Delete Listener %s from database error: %s" %
(lbl_id, err))
return console_response(
code=LoadBalancerErrorCode.DELETE_LISTENER_ERROR, msg=str(err))
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbl_id])
def describe_loadbalancer_listeners(payload):
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
if not lbl_id:
lbl_id_list = ListenersModel.get_lbl_by_lb_id(lb_id)
else:
lbl_id_list = [ListenersModel.get_lbl_by_id(lbl_id)]
lb = LoadbalancerModel.get_lb_by_id(lb_id)
# call backend
resp = describe_loadbalancers_api(payload, loadbalancer_id=lb.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
lbl_list = []
for lbl in lbl_id_list:
# lbl = ListenersModel.get_lbl_by_id(lbl_id)
lbp = lbl.pool
lbhm = lbp.healthmonitor
lbms = MembersModel.get_lbm_by_lbl_id(lbl.lbl_id)
info = {
"lbl_id": lbl.lbl_id,
"name": lbl.name,
"protocol": lbl.protocol,
"protocol_port": lbl.protocol_port,
"lb_algorithm": lbp.lb_algorithm,
"session_persistence_type": lbp.session_persistence_type,
"cookie_name": lbp.cookie_name,
"health_check_type": lbhm.type,
"health_check_delay": lbhm.delay,
"health_check_timeout": lbhm.timeout,
"health_check_max_retries": lbhm.max_retries,
"health_check_url_path": lbhm.url_path,
"health_check_expected_codes": lbhm.expected_codes,
}
members = []
if lbms:
# members_status = list_to_dict(lbls_statuses.get(lbl.uuid, {}).get("pools", [])[0].get("members", []))
members_status = describe_member_status_api(
payload,
[lbm.lbm_id for lbm in lbms]).get("data",
{}).get("ret_set", [{}])[0]
for lbm in lbms:
member_info = {
"lbm_id": lbm.lbm_id,
"instance_id": lbm.instance.instance_id,
"instance_name": lbm.instance.name,
"address": lbm.address,
"port": lbm.port,
"weight": lbm.weight,
"status": transfer_member_status(members_status.get(lbm.uuid))
}
members.append(member_info)
info.update({"members": members})
lbl_list.append(info)
return console_response(code=Code.OK,
msg=msg,
total_count=len(lbl_list),
ret_set=lbl_list)
def create_loadbalancer_listener(payload):
zone = payload.get("zone")
owner = payload.get("owner")
lb_id = payload.pop("lb_id")
lbl_name = payload.pop("lbl_name")
protocol = payload.pop("protocol")
protocol_port = payload.pop("protocol_port")
lb_algorithm = payload.pop("lb_algorithm")
health_check_type = payload.pop("health_check_type")
health_check_delay = payload.pop("health_check_delay")
health_check_timeout = payload.pop("health_check_timeout")
health_check_max_retries = payload.pop("health_check_max_retries")
session_persistence_type = payload.pop("session_persistence_type")
health_check_url_path = payload.pop("health_check_url_path")
health_check_expected_codes = payload.pop("health_check_expected_codes")
cookie_name = payload.pop("cookie_name")
# step 0 check args
if not check_protocol_port(lb_id, protocol_port):
msg = "Listener Port CONFLICT"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.LISTENER_PORT_CONFLICT, msg=msg)
if not check_session_persistence(protocol, session_persistence_type,
cookie_name):
msg = "Cookie Name NOT Found"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.COOKIE_NAME_NOT_FOUND, msg=msg)
# step 1 create listener in backend
lbl_id = make_lbl_id()
lb = LoadbalancerModel.get_lb_by_id(lb_id)
resp_listener = create_listener_api(payload, lbl_id, lb.uuid, protocol,
protocol_port)
api_code1 = resp_listener.get("data", {}).get("ret_code")
code1 = resp_listener.get("code", -1)
msg1 = resp_listener.get("msg", "failed")
if code1 != Code.OK:
code1 = convert_api_code(api_code1)
return console_response(code=code1, msg=msg1)
ret_listener = resp_listener.get("data", [{}]).get("ret_set", [])[0]
logger.debug(resp_listener)
logger.debug(ret_listener)
if not ret_listener:
msg = "Create Listener Error from Backend"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.CREATE_LISTENER_ERROR, msg=msg)
listener_uuid = ret_listener.get("id")
# step 2 create pool in backend
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
lbp_id = make_lbp_id()
logger.debug("lbp_id %s" % lbp_id)
resp_pool = create_pool_api(payload,
lbp_id,
listener_uuid,
protocol,
lb_algorithm,
session_persistence_type,
cookie_name=cookie_name)
api_code2 = resp_pool.get("data", {}).get("ret_code")
code2 = resp_pool.get("code", -1)
msg2 = resp_pool.get("msg", "failed")
if code2 != Code.OK:
code2 = convert_api_code(api_code2)
return console_response(code=code2, msg=msg2)
ret_pool = resp_pool.get("data", {}).get("ret_set", [{}])[0]
if not ret_pool:
msg = "Create Pool Error from Backend"
logger.error(msg)
return console_response(code=LoadBalancerErrorCode.CREATE_POOL_ERROR,
msg=msg)
pool_uuid = ret_pool.get("id")
# step 3 create health monitor
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
lbhm_id = make_lbhm_id()
logger.debug("lbhm_id %s" % lbhm_id)
resp_healthmonitor = create_healthmonitor_api(
payload,
pool_uuid,
health_check_type,
health_check_delay,
health_check_timeout,
health_check_max_retries,
url_path=health_check_url_path,
expected_codes=health_check_expected_codes)
api_code3 = resp_healthmonitor.get("data", {}).get("ret_code")
code3 = resp_healthmonitor.get("code", -1)
msg3 = resp_healthmonitor.get("msg", "failed")
if code3 != Code.OK:
code3 = convert_api_code(api_code3)
return console_response(code=code3, msg=msg3)
ret_healthmonitor = resp_healthmonitor.get("data",
{}).get("ret_set", [{}])[0]
if not ret_healthmonitor:
msg = "Create HealthMonitor Error from Backend"
logger.error(msg)
return console_response(code=LoadBalancerErrorCode.CREATE_POOL_ERROR,
msg=msg)
healthmonitor_uuid = ret_healthmonitor.get("id")
# step 4 save health monitor
lbhm, err = save_lb_healthmonitor(zone, owner, lbhm_id, healthmonitor_uuid,
health_check_type, health_check_delay,
health_check_timeout,
health_check_max_retries,
health_check_url_path,
health_check_expected_codes)
if err:
logger.error("Save LB Health Monitor %s from database error: %s" %
(lbhm_id, err))
return console_response(
code=LoadBalancerErrorCode.SAVE_LB_HEALTHMONITOR_ERROR,
msg=str(err))
# step 5 save pool
lbp, err = save_lb_pool(zone, owner, lbp_id, pool_uuid, lbhm_id,
lb_algorithm, session_persistence_type,
cookie_name)
if err:
logger.error("Save LB Pool %s from database error: %s" %
(lbhm_id, err))
return console_response(code=LoadBalancerErrorCode.SAVE_LB_POOL_ERROR,
msg=str(err))
# step 6 save listener
lbl, err = save_lb_listener(zone, owner, lbl_id, listener_uuid, lb_id,
lbp_id, lbl_name, protocol, protocol_port)
if err:
logger.error("Save LB Listener %s from database error: %s" %
(lbhm_id, err))
return console_response(
code=LoadBalancerErrorCode.SAVE_LB_LISTENER_ERROR, msg=str(err))
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbl_id])
def describe_loadbalancers(payload):
zone = payload.get("zone")
owner = payload.get("owner")
lb_id = payload.pop("lb_id", None)
features = payload.pop("features", [])
if lb_id:
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lb_uuid = lb.uuid
else:
lb_uuid = None
# call backend
resp = describe_loadbalancers_api(payload, loadbalancer_id=lb_uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
lb_set = resp.get("data", {}).get("ret_set", [])
lb_list = []
for single in lb_set:
lb_id = single.get("name", None)
raw_status = single.get("provisioning_status", None)
if lb_id and LoadbalancerModel.lb_exists_by_id(lb_id):
lb = LoadbalancerModel.get_lb_by_id(lb_id)
else:
continue
info = {
"lb_id": lb_id,
"lb_name": lb.name,
"create_datetime": datetime_to_timestamp(lb.create_datetime),
"status": transfer_lb_status(raw_status),
}
net_info = {"is_basenet": lb.is_basenet}
if not lb.is_basenet:
net_payload = {
"zone": zone,
"owner": owner,
"action": "DescribeNets",
"subnet_id": lb.net_id
}
resp = api.get(net_payload)
net_data = resp['data']['ret_set'][0]
net_type = 'private' if net_data.get(
'gateway_ip') is None else 'public'
net_info.update({"net_type": net_type})
net_info.update({"net_id": lb.net_id})
net_info.update({"net_name": net_data['name']})
info.update({"net": net_info})
ip_info = {"vip_addr": single.get("vip_address", None)}
logger.debug('single: ')
logger.debug(single)
fip_info = single.get("fip_info")
if fip_info:
fip_uuid = fip_info["ip_uuid"]
fip_address = fip_info["ip_address"]
ip = IpsModel.get_ip_by_uuid(fip_uuid)
ip_info.update({"ip_id": ip.ip_id})
ip_info.update({"fip_addr": fip_address})
ip_info.update({"bandwidth": ip.bandwidth})
info.update({"ip": ip_info})
for feature in features:
if 'elastic' == feature:
elastic = ElasticGroupService.get_by_loadbalance_id(lb_id)
if elastic:
serializer = DescribeLoadbalancerSerializer(elastic)
info.update({'elastic': serializer.data})
lb_list.append(info)
lb_list = sorted(lb_list,
key=lambda x: x.get("create_datetime"),
reverse=True)
return console_response(code=Code.OK,
msg=msg,
total_count=len(lb_list),
ret_set=lb_list)
def describe_loadbalancer_by_id(payload):
"""
{
'admin_state_up': True,
'description': '',
'fip_info': None,
'id': 'cb40c835-6d00-4fd6-8b7b-b8152c5227a0',
'listeners': [{'id': 'ec25dbbc-3d3b-4196-b2f8-2868a3c5d1a1'}],
'name': 'lb-8nfz3dwg',
'operating_status': 'ONLINE',
'provider': 'haproxy',
'provisioning_status': 'ACTIVE',
'statuses': {
'loadbalancer': {
'id': 'cb40c835-6d00-4fd6-8b7b-b8152c5227a0',
'listeners': [
{
'id': 'ec25dbbc-3d3b-4196-b2f8-2868a3c5d1a1',
'name': 'lbl-9cxezd2h',
'operating_status': 'ONLINE',
'pools': [
{
'healthmonitor': {
'id': '2f4507f1-88c8-4505-84a5-70aa5cf3d8d9',
'provisioning_status': 'ACTIVE',
'type': 'TCP'
},
'id': '93873e55-647d-43fd-86ca-b5e63012759b',
'members': [],
'name': 'lbp-de9w2i4m',
'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE'
}
],
'provisioning_status': 'ACTIVE'
}
],
'name': 'lb-8nfz3dwg',
'operating_status': 'ONLINE',
'provisioning_status': 'ACTIVE'
}
},
'tenant_id': '114899e0545b43b6a389b7bc2cb5fe34',
'vip_address': '173.10.10.45',
'vip_port_id': '24972ad3-8bb5-45d5-afbd-2161add7075f',
'vip_subnet_id': '01e93e64-0a24-408d-b893-dabe1760ac2a'
}
"""
lb = LoadbalancerModel.get_lb_by_id(payload.pop("lb_id"))
resp = describe_loadbalancers_api(payload, loadbalancer_id=lb.uuid)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
else:
info = resp['data']['ret_set'].pop()
return console_response(code=Code.OK,
msg=msg,
total_count=1,
ret_set=info)
def describe_nets(payload):
if not payload.get("subnet_id"):
payload.pop("subnet_id", None)
page_index = payload.pop("page_index", None)
page_size = payload.pop("page_size", None)
logger.debug("payload is %s", payload)
resp = api.get(payload=payload)
subnet_type = payload.get("subnet_type")
code = resp["code"]
msg = resp["msg"]
api_code = resp["data"].get("ret_code", -1)
api_status = resp['api_status']
if code != Code.OK:
code = convert_api_code(api_code)
logger.error(
"DescribeNets error: api_ret_code (%d), api_status (%d), msg (%s)"
% (api_code, api_status, msg))
return console_response(code=code, msg=msg)
net_set = resp["data"].get("ret_set", [])
net_list = []
net2lbs = LoadbalancerModel.get_net2lbs()
for n in net_set:
# net_id = n["name"]
# if NetsModel.net_exists_by_id(net_id):
# inst = NetsModel.get_net_by_id(net_id=net_id)
# else:
# logger.error("DescribeNets %s donot exists in Database" % net_id)
# continue
# if inst:
# name = inst.name
# else:
# name = _("Unknown")
# add for output
# n.update({"create_datetime": inst.create_datetime})
# n.update({"type": inst.net_type})
# n.update({"net_name": name})
# add instance info
sn = n.get("name", '')
if subnet_type:
if subnet_type == "KVM":
if sn.startswith(SUBNET_TYPE["VMWARE"]) or \
sn.startswith(SUBNET_TYPE["POWERVM"]):
continue
elif not sn.startswith(SUBNET_TYPE[subnet_type]):
continue
else:
n['name'] = n['name'][int(len(SUBNET_TYPE[subnet_type])):]
'''
user = payload.get("name")
public, user_list = SubnetAttributes.objects.get_pub_and_userlist_by_subnetid(n.get("id"))
if (public or user in user_list):
net_list.append(n)
'''
net_id = n.get('id')
lbs = net2lbs.get(net_id, [])
n['lbs'] = lbs
net_list.append(n)
net_list = filter_needed_net_info(net_list)
total_count = len(net_list)
if page_size and net_list:
net_list = net_list[(page_index - 1) *
page_size:page_index * page_size or None]
return console_response(code=Code.OK,
msg=msg,
total_count=total_count,
ret_set=net_list)
def update_loadbalancer_listener(payload):
lb_id = payload.pop("lb_id")
lbl_id = payload.pop("lbl_id")
lbl_name = payload.pop("lbl_name")
lb_algorithm = payload.pop("lb_algorithm")
health_check_type = payload.pop("health_check_type")
health_check_delay = payload.pop("health_check_delay")
health_check_timeout = payload.pop("health_check_timeout")
health_check_max_retries = payload.pop("health_check_max_retries")
session_persistence_type = payload.pop("session_persistence_type")
health_check_url_path = payload.pop("health_check_url_path")
health_check_expected_codes = payload.pop("health_check_expected_codes")
cookie_name = payload.pop("cookie_name")
lb = LoadbalancerModel.get_lb_by_id(lb_id)
lbl = ListenersModel.get_lbl_by_id(lbl_id)
protocol = lbl.protocol
pool = lbl.pool
healthmonitor = pool.healthmonitor
# step 0 check args
if not check_session_persistence(protocol, session_persistence_type,
cookie_name):
msg = "Cookie Name NOT Found"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.COOKIE_NAME_NOT_FOUND, msg=msg)
# step 1 update lbl name
if lbl.name != lbl_name:
lbl.name = lbl_name
lbl.save()
# step 2 update the pool: first check if needed
need_update = False
if pool.lb_algorithm != lb_algorithm or \
pool.session_persistence_type != session_persistence_type or \
pool.cookie_name != cookie_name:
need_update = True
pool.lb_algorithm = lb_algorithm
pool.session_persistence_type = session_persistence_type
pool.cookie_name = cookie_name
if need_update:
resp = update_pool_api(payload,
pool.uuid,
lb_algorithm,
session_persistence_type,
cookie_name=cookie_name)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
pool.save()
# step 3 update the healthmonitor
# check if need update or need recreate
need_update = False
need_recreate = False
if healthmonitor.type != health_check_type:
need_recreate = True
elif healthmonitor.delay != health_check_delay or \
healthmonitor.timeout != health_check_timeout or \
healthmonitor.max_retries != health_check_max_retries or \
healthmonitor.url_path != health_check_url_path or healthmonitor.expected_codes != health_check_expected_codes:
need_update = True
# update healthmonitor data in database
if need_update or need_recreate:
healthmonitor.type = health_check_type
healthmonitor.delay = health_check_delay
healthmonitor.timeout = health_check_timeout
healthmonitor.max_retries = health_check_max_retries
healthmonitor.url_path = health_check_url_path
healthmonitor.expected_codes = health_check_expected_codes
# if need recreate
if need_recreate:
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
# delete healthmonitor
resp_healthmonitor = delete_healthmonitor_api(payload,
healthmonitor.uuid)
api_code3 = resp_healthmonitor.get("data", {}).get("ret_code")
code3 = resp_healthmonitor.get("code", -1)
msg3 = resp_healthmonitor.get("msg", "failed")
if code3 != Code.OK:
code3 = convert_api_code(api_code3)
return console_response(code=code3, msg=msg3)
# create a new healthmonitor
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
lbhm_id = make_lbhm_id()
logger.debug("lbhm_id %s" % lbhm_id)
resp_healthmonitor = create_healthmonitor_api(
payload,
pool.uuid,
health_check_type,
health_check_delay,
health_check_timeout,
health_check_max_retries,
url_path=health_check_url_path,
expected_codes=health_check_expected_codes)
api_code3 = resp_healthmonitor.get("data", {}).get("ret_code")
code3 = resp_healthmonitor.get("code", -1)
msg3 = resp_healthmonitor.get("msg", "failed")
if code3 != Code.OK:
code3 = convert_api_code(api_code3)
return console_response(code=code3, msg=msg3)
ret_healthmonitor = resp_healthmonitor.get("data",
{}).get("ret_set", [{}])[0]
if not ret_healthmonitor:
msg = "Create HealthMonitor Error from Backend"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.CREATE_POOL_ERROR, msg=msg)
healthmonitor_uuid = ret_healthmonitor.get("id")
healthmonitor.uuid = healthmonitor_uuid
elif need_update:
# wait for listener status is ACTIVE
flag, err = wait_for_lb_status(payload, lb.uuid, LB_STATUS.ACTIVE)
if not flag:
msg = "Wait Loadbalancer Status Error"
logger.error(msg)
return console_response(
code=LoadBalancerErrorCode.WAIT_LB_STATUS_ERROR, msg=msg)
resp_healthmonitor = update_healthmonitor_api(
payload,
healthmonitor.uuid,
healthmonitor.type,
health_check_delay,
health_check_timeout,
health_check_max_retries,
url_path=health_check_url_path,
expected_codes=health_check_expected_codes)
api_code3 = resp_healthmonitor.get("data", {}).get("ret_code")
code3 = resp_healthmonitor.get("code", -1)
msg3 = resp_healthmonitor.get("msg", "failed")
if code3 != Code.OK:
code3 = convert_api_code(api_code3)
return console_response(code=code3, msg=msg3)
# step 4 save healthmonitor
if need_recreate or need_update:
healthmonitor.save()
code, msg = Code.OK, "succ"
return console_response(code=code,
msg=msg,
total_count=1,
ret_set=[lbl_id])
def describe_ips(payload, internal=False):
"""
Describe ip(s)
"""
# to_syn = True
# if internal is True:
# # print "modify_ip_bandwidth called"
# to_syn = False
# else:
# # print "describe_ip called"
# for key, value in dict(payload).items():
# if key in DESCRIPTIVE_FILTER_PARAMETER:
# if value:
# to_syn = False
# break
######################################
ip_ids = payload.pop("ip_id", [])
subnet_name = payload.get("subnet_name", [])
page_index = payload.pop("page_index", None)
page_size = payload.pop("page_size", None)
# if not ip_ids:
# ip_inst = IpsModel.get_ip_by_id(ip_ids)
# if ip_inst:
# ip_uuid = ip_inst.uuid
# payload.update({"floatingip_id": ip_uuid})
# resp = api.get(payload=payload, timeout=10) # call api
resp = api.get(payload=payload) # call api
code = resp.get("code")
msg = resp["msg"]
api_code = resp["data"].get('ret_code', -1)
if code != 0:
ret_code = convert_api_code(api_code)
return console_response(code=ret_code, msg=msg)
ip_set = resp["data"].get("ret_set", [])
if ip_ids:
ip_set = filter_needed_ip_set(ip_set, ip_ids)
if subnet_name:
ip_list = sorted(filter_subnet_pubips(ip_set),
key=lambda x: x.get("create_datetime"),
reverse=True)
else:
ip_list = sorted(filter_needed_ip_info(ip_set),
key=lambda x: x.get("create_datetime"),
reverse=True)
resp["data"]["ret_set"] = ip_list[
(page_index - 1) *
page_size:page_index * page_size or None] if page_size else ip_list
resp["data"]["total_count"] = len(ip_list)
# remove 'action'
resp["data"].pop("action")
ret_set = resp.get('data', {}).get('ret_set', [])
total_count = resp.get("data", {}).get("total_count", 0)
# if to_syn:
# synchronize_bandwidth(ret_set, payload["owner"], payload["zone"])
return console_response(code=0,
msg="succ",
total_count=total_count,
ret_set=ret_set)
def create_loadbalancer(payload):
zone = payload.get("zone")
owner = payload.get("owner")
use_basenet = payload.pop("use_basenet")
name = payload.pop("lb_name")
net_id = payload.pop("net_id", None)
ip_id = payload.pop("ip_id", None)
lb_id = make_lb_id()
subnet_id = None
if not use_basenet:
if net_id:
subnet_id = net_id
net_payload = {
"zone": zone,
"owner": owner,
"action": "DescribeNets",
"subnet_id": subnet_id
}
resp = api.get(net_payload)
net_type = 'private' if resp['data']['ret_set'][0].get(
'gateway_ip') is None else 'public'
else:
msg = "Net NOT FOUND"
return console_response(code=LoadBalancerErrorCode.NET_NOT_FOUND,
msg=msg)
else:
net_type = NET_TYPE.PUBLIC
# call backend
resp = create_loadbalancer_api(payload,
lb_id,
use_basenet,
subnet_id=subnet_id)
api_code = resp.get("data", {}).get("ret_code")
code = resp.get("code", -1)
msg = resp.get("msg", "failed")
if code != Code.OK:
code = convert_api_code(api_code)
return console_response(code=code, msg=msg)
uuid = resp.get("data", {}).get("ret_set", [])[0].get("id")
lb, err = save_lb(zone, owner, lb_id, uuid, name, use_basenet, net_id)
if err:
logger.error("Save LB %s from database error: %s" % (lb_id, err))
return console_response(code=LoadBalancerErrorCode.SAVE_LB_ERROR,
msg=str(err))
if net_type == NET_TYPE.PUBLIC and ip_id:
# TODO Bind IP to LB
resp = bind_loadbalancer_ip({
"owner": owner,
"zone": zone,
"ip_id": ip_id,
"lb_id": lb_id
})
if resp["ret_code"] != Code.OK:
logger.error("Loadbalancer %s BindIP %s erorr %s" %
(lb_id, ip_id, resp["msg"]))
code, msg = Code.OK, "succ"
return console_response(code=code, msg=msg, total_count=1, ret_set=[lb_id])