def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Option VIP.
URL: vip/dsrl3//all'
"""
try:
self.log.info("GET to list all the DSRL3 of VIPs")
# User permission
if not has_perm(user, AdminPermission.OPTION_VIP, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Find All Option VIP
dsrl3 = DsrL3_to_Vip.get_all()
ovips = []
for ov in dsrl3:
ovips.append(model_to_dict(ov))
return self.response(dumps_networkapi({'dsrl3': ovips}))
except UserNotAuthorizedError:
return self.not_authorized()
except OptionVipError:
return self.response_error(1)
def get_by_pk(pk):
"""
Get Vip Request By Pk
:param pk: Identifier For Vip Request
:return: Dict
"""
if not is_valid_int_greater_zero_param(pk):
raise exceptions.InvalidIdVipRequestException()
vip_request = RequisicaoVips.objects.get(id=pk)
data = vip_request.variables_to_map()
data['id'] = vip_request.id
data['validado'] = convert_boolean_to_int(vip_request.validado)
data['vip_criado'] = convert_boolean_to_int(vip_request.vip_criado)
data['id_ip'] = vip_request.ip_id
data['id_ipv6'] = vip_request.ipv6_id
data['id_healthcheck_expect'] = vip_request.healthcheck_expect_id
data['l7_filter'] = vip_request.l7_filter
data['rule_id'] = vip_request.rule_id
data['trafficreturn'] = vip_request.trafficreturn.nome_opcao_txt
data['dsrl3']=999
try:
dsrl3_to_vip_obj = DsrL3_to_Vip.get_by_vip_id(vip_request.id)
data['dsrl3'] = dsrl3_to_vip_obj.id_dsrl3
except ObjectDoesNotExist, e:
pass
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Option VIP.
URL: vip/dsrl3//all'
"""
try:
self.log.info('GET to list all the DSRL3 of VIPs')
# User permission
if not has_perm(user, AdminPermission.OPTION_VIP,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Find All Option VIP
dsrl3 = DsrL3_to_Vip.get_all()
ovips = []
for ov in dsrl3:
ovips.append(model_to_dict(ov))
return self.response(dumps_networkapi({'dsrl3': ovips}))
except UserNotAuthorizedError:
return self.not_authorized()
except OptionVipError:
return self.response_error(1)
def save(request):
"""
Save Vip Request
:param request: Request
:return: Data Serialized Post Save
"""
data = request.DATA
user = request.user
req_vip_serializer = RequestVipSerializer(
data=data
)
if not req_vip_serializer.is_valid():
log.error(req_vip_serializer.errors)
raise api_exceptions.ValidationException()
obj_req_vip = req_vip_serializer.object
# valid if pools member can linked by environment/environment vip
# relationship rule
server_pool_ips_can_associate_with_vip_request(obj_req_vip)
obj_req_vip.filter_valid = True
obj_req_vip.validado = False
set_l7_filter_for_vip(obj_req_vip)
obj_req_vip.set_new_variables(data)
# obj_req_vip.trafficreturn=OptionVip.get_by_pk(int(data['trafficreturn']))
if obj_req_vip.trafficreturn is None:
obj_req_vip.trafficreturn = OptionVip.get_by_pk(12)
obj_req_vip.save(user)
if obj_req_vip.trafficreturn.nome_opcao_txt == 'DSRL3':
dsrl3_to_vip_obj = DsrL3_to_Vip()
dsrl3_to_vip_obj.get_dsrl3(obj_req_vip, user)
for v_port in obj_req_vip.vip_ports_to_pools:
v_port.requisicao_vip = obj_req_vip
v_port.save()
# SYNC_VIP
syncs.old_to_new(obj_req_vip)
return req_vip_serializer.data
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find all Vip Requests by id.
URLs: /requestvip/getbyid/id_vip
"""
self.log.info('Find Vip Request by id')
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VIPS_REQUEST, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Business Validations
# Valid id access
id_vip = kwargs.get('id_vip')
if not is_valid_int_greater_zero_param(id_vip):
self.log.error(
u'Parameter id_vip is invalid. Value: %s.', id_vip)
raise InvalidValueError(None, 'id_vip', id_vip)
vip = RequisicaoVips.get_by_pk(id_vip)
vip_map = vip.variables_to_map()
""""""
vip_port_list, reals_list, reals_priority, reals_weight = vip.get_vips_and_reals(
vip.id)
if reals_list:
vip_map['reals'] = {'real': reals_list}
vip_map['reals_prioritys'] = {'reals_priority': reals_priority}
vip_map['reals_weights'] = {'reals_weight': reals_weight}
if vip_port_list:
vip_map['portas_servicos'] = {'porta': vip_port_list}
""""""
vip_map['id'] = id_vip
vip_map['validado'] = vip.validado
vip_map['vip_criado'] = vip.vip_criado
vip_map['rule_id'] = vip.rule_id
vip_map[
'trafficreturn'] = vip.trafficreturn.nome_opcao_txt if vip.trafficreturn else ''
try:
dsrl3_to_vip_obj = DsrL3_to_Vip.get_by_vip_id(vip.id)
vip_map['dsrl3'] = dsrl3_to_vip_obj.id_dsrl3
except ObjectDoesNotExist, e:
pass
# Maxcon, lbmethod e hc
vip_map['maxcon'] = 0
vip_map['metodo_bal'] = ''
vip_map['healthcheck'] = ''
vip_map['healthcheck_type'] = ''
pools = []
pool_to_use = None
id_pools = vip.vipporttopool_set.values_list(
'server_pool_id', flat=True)
if len(id_pools) > 0:
pools = ServerPool.objects.filter(
id__in=id_pools).order_by('id')
pool_to_use = pools[0]
for pool in pools:
if pool.healthcheck:
hc = pool.healthcheck.healthcheck_type
if hc == 'HTTP':
pool_to_use = pool
break
if pool_to_use:
vip_map['maxcon'] = pool_to_use.default_limit
vip_map['metodo_bal'] = pool_to_use.lb_method
vip_map[
'servicedownaction'] = pool_to_use.servicedownaction.name if pool_to_use.servicedownaction else ''
vip_map[
'healthcheck_type'] = pool.healthcheck.healthcheck_type if pool.healthcheck else ''
if vip_map['healthcheck_type'] in ('HTTP', 'HTTPS'):
vip_map[
'healthcheck'] = pool.healthcheck.healthcheck_request if pool.healthcheck else ''
if vip.healthcheck_expect is not None:
vip_map['id_healthcheck_expect'] = vip.healthcheck_expect.id
vip_map['expect_string'] = vip.healthcheck_expect.expect_string
vip_map['match_list'] = vip.healthcheck_expect.match_list
else:
vip_map['expect_string'] = ''
vip_map['match_list'] = ''
list_equips = []
list_ips = list()
list_environment = []
descricao_ipv4 = None
descricao_ipv6 = None
if vip.ip is not None:
descricao_ipv4 = vip.ip.descricao
list_ips.append(
'%s.%s.%s.%s' % (vip.ip.oct1, vip.ip.oct2, vip.ip.oct3, vip.ip.oct4))
list_environment.append('%s - %s - %s' % (vip.ip.networkipv4.vlan.ambiente.divisao_dc.nome,
vip.ip.networkipv4.vlan.ambiente.ambiente_logico.nome, vip.ip.networkipv4.vlan.ambiente.grupo_l3.nome))
equips = vip.ip.ipequipamento_set.all()
for equip in equips:
if equip.equipamento.nome not in list_equips:
list_equips.append(equip.equipamento.nome)
if vip.ipv6 is not None:
descricao_ipv6 = vip.ipv6.description
list_ips.append('%s:%s:%s:%s:%s:%s:%s:%s' % (vip.ipv6.block1, vip.ipv6.block2, vip.ipv6.block3,
vip.ipv6.block4, vip.ipv6.block5, vip.ipv6.block6, vip.ipv6.block7, vip.ipv6.block8))
list_environment.append('%s - %s - %s' % (vip.ipv6.networkipv6.vlan.ambiente.divisao_dc.nome,
vip.ipv6.networkipv6.vlan.ambiente.ambiente_logico.nome, vip.ipv6.networkipv6.vlan.ambiente.grupo_l3.nome))
equips = vip.ipv6.ipv6equipament_set.all()
for equip in equips:
if equip.equipamento.nome not in list_equips:
list_equips.append(equip.equipamento.nome)
vip_map['ipv4_description'] = descricao_ipv4
vip_map['ipv6_description'] = descricao_ipv6
vip_map['environments'] = list_environment
vip_map['ips'] = list_ips
vip_map['equipamento'] = list_equips
# Business Rules
# Start with alls
returned_map = dict()
returned_map['vip'] = [vip_map]
return self.response(dumps_networkapi(returned_map))
def old_to_new(vip_request):
from networkapi.ambiente.models import EnvironmentVip
from networkapi.api_vip_request.models import VipRequest, VipRequestDSCP, VipRequestOptionVip, \
VipRequestPort, VipRequestPortOptionVip, VipRequestPortPool
from networkapi.requisicaovips.models import DsrL3_to_Vip, OptionVip, OptionVipEnvironmentVip, \
VipPortToPool
mp = vip_request.variables_to_map()
try:
try:
ev = EnvironmentVip().get_by_values(
mp['finalidade'], mp['cliente'], mp['ambiente'])
except:
ev = EnvironmentVip()
ev.finalidade_txt = mp['finalidade']
ev.cliente_txt = mp['cliente']
ev.ambiente_p44_txt = mp['ambiente']
ev.description = '%s - %s - %s' % (
mp['finalidade'], mp['cliente'], mp['ambiente'])
ev.save()
finally:
vp = VipRequest()
vp.environmentvip = ev
vp.id = vip_request.id
vp.name = mp['host'] if mp.get('host') else None
vp.business = mp['areanegocio'] if mp.get(
'areanegocio') else vp.name
vp.service = mp['nome_servico'] if mp.get(
'nome_servico') else vp.name
vp.ipv4 = vip_request.ip if vip_request.ip else None
vp.ipv6 = vip_request.ipv6 if vip_request.ipv6 else None
vp.created = vip_request.vip_criado
vp.save()
if mp.get('persistencia'):
persistencia = mp['persistencia']
else:
persistencia = '(nenhum)'
try:
op_per = OptionVip.objects.filter(
tipo_opcao=u'Persistencia',
nome_opcao_txt=persistencia)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_per,
environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_per
opv.environment = ev
opv.save()
except:
op_per = OptionVip()
op_per.tipo_opcao = u'Persistencia'
op_per.nome_opcao_txt = persistencia
op_per.save()
opv = OptionVipEnvironmentVip()
opv.option = op_per
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestOptionVip.objects.get(
optionvip=op_per,
vip_request=vp)
except:
vro = VipRequestOptionVip()
vro.optionvip = op_per
vro.vip_request = vp
vro.save()
if mp.get('timeout'):
timeout = mp['timeout']
else:
timeout = '5'
try:
op_time = OptionVip.objects.filter(
tipo_opcao=u'timeout',
nome_opcao_txt=timeout)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_time,
environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_time
opv.environment = ev
opv.save()
except:
op_time = OptionVip()
op_time.tipo_opcao = u'timeout'
op_time.nome_opcao_txt = timeout
op_time.save()
opv = OptionVipEnvironmentVip()
opv.option = op_time
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestOptionVip.objects.get(
optionvip=op_time,
vip_request=vp)
except:
vro = VipRequestOptionVip()
vro.optionvip = op_time
vro.vip_request = vp
vro.save()
if mp.get('trafficreturn'):
trafficreturn = mp['trafficreturn']
else:
trafficreturn = 12
try:
op_traffic = OptionVip.objects.filter(
tipo_opcao=u'Retorno de trafego',
id=trafficreturn)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_traffic,
environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_traffic
opv.environment = ev
opv.save()
except:
op_traffic = OptionVip()
op_traffic.tipo_opcao = u'Retorno de trafego'
op_traffic.nome_opcao_txt = trafficreturn
op_traffic.save()
opv = OptionVipEnvironmentVip()
opv.option = op_traffic
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestOptionVip.objects.get(
optionvip=op_traffic,
vip_request=vp)
except:
vro = VipRequestOptionVip()
vro.optionvip = op_traffic
vro.vip_request = vp
vro.save()
if int(trafficreturn) == 48:
dsrl3 = DsrL3_to_Vip.get_by_vip_id(vip_request.id)
try:
vp_dsrl3 = VipRequestDSCP.objects.get(vip_request=vp)
except:
vp_dsrl3 = VipRequestDSCP()
vp_dsrl3.vip_request = vp
vp_dsrl3.dscp = dsrl3.id_dsrl3
vp_dsrl3.save()
else:
try:
vp_dsrl3 = VipRequestDSCP.objects.get(vip_request=vp)
vp_dsrl3.delete()
except:
pass
if mp.get('cache'):
cache = mp['cache']
else:
cache = '(nenhum)'
try:
op_cache = OptionVip.objects.filter(
tipo_opcao=u'cache',
nome_opcao_txt=cache)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_cache,
environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_cache
opv.environment = ev
opv.save()
except:
op_cache = OptionVip()
op_cache.tipo_opcao = u'cache'
op_cache.nome_opcao_txt = cache
op_cache.save()
opv = OptionVipEnvironmentVip()
opv.option = op_cache
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestOptionVip.objects.get(
optionvip=op_cache,
vip_request=vp)
except:
vro = VipRequestOptionVip()
vro.optionvip = op_cache
vro.vip_request = vp
vro.save()
# delete optionvip(op_cache, op_traffic, op_time, op_per)
# in port removed in old table
VipRequestOptionVip.objects.filter(
vip_request=vp
).exclude(
optionvip__id__in=[op_cache.id, op_traffic.id,
op_time.id, op_per.id]
).delete()
pools = VipPortToPool.get_by_vip_id(vip_request.id)
# delete old ports
ports_current = VipRequestPort.objects.filter(vip_request=vp)
ports_ids = [port.id for port in ports_current]
pools_ids = [pl.id for pl in pools]
ids_to_del = list(set(ports_ids) - set(pools_ids))
ports_current.filter(id__in=ids_to_del).delete()
# delete pools removed in old table
# ptid = [ptid.server_pool.id for ptid in pools]
# VipRequestPortPool.objects.filter(
# vip_request_port=vrp
# ).exclude(
# server_pool__id__in=ptid
# ).delete()
for pool in pools:
# saving ports of vip
vrp = VipRequestPort()
vrp.id = pool.id
vrp.vip_request = vp
vrp.port = pool.port_vip
if not pool.identifier:
from networkapi.api_equipment import facade as facade_eqpt
from networkapi.plugins.factory import PluginFactory
eqpts = facade_eqpt.get_eqpt_by_envvip(ev.id)
if eqpts:
plugin = PluginFactory.factory(eqpts[0])
vrp.identifier = plugin.get_name_eqpt(
vp, pool.port_vip)
pool.identifier = vrp.identifier
pool.save()
vrp.save()
# descobre protocolo l7 e l4
tipo_opcao = 'l7_rule'
nome_opcao_txt = 'default_vip'
l4_protocol = 'TCP'
l7_protocol = 'Outros'
if mp.get('healthcheck_type') == 'HTTP':
tipo_opcao = 'l7_rule'
nome_opcao_txt = 'default_vip'
l4_protocol = 'TCP'
l7_protocol = 'HTTP'
if mp.get('healthcheck_type') == 'TCP':
l4_protocol = 'TCP'
l7_protocol = 'Outros'
if mp.get('healthcheck_type') == 'UDP':
l4_protocol = 'UDP'
l7_protocol = 'Outros'
if pool.port_vip == 20 or pool.port_vip == 21:
l4_protocol = 'TCP'
l7_protocol = 'FTP'
if pool.port_vip == 443:
l4_protocol = 'TCP'
l7_protocol = 'HTTPS'
# l4_protocol
try:
op_l4 = OptionVip.objects.filter(
tipo_opcao='l4_protocol', nome_opcao_txt=l4_protocol)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_l4, environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_l4
opv.environment = ev
opv.save()
except:
op_l4 = OptionVip()
op_l4.tipo_opcao = u'l4_protocol'
op_l4.nome_opcao_txt = l4_protocol
op_l4.save()
opv = OptionVipEnvironmentVip()
opv.option = op_l4
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestPortOptionVip.objects.filter(
optionvip=op_l4, vip_request_port=vrp)[0]
except:
vro = VipRequestPortOptionVip()
vro.optionvip = op_l4
vro.vip_request_port = vrp
vro.save()
# l7_protocol
try:
op_l7 = OptionVip.objects.filter(
tipo_opcao='l7_protocol', nome_opcao_txt=l7_protocol)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_l7, environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_l7
opv.environment = ev
opv.save()
except:
op_l7 = OptionVip()
op_l7.tipo_opcao = u'l7_protocol'
op_l7.nome_opcao_txt = l7_protocol
op_l7.save()
opv = OptionVipEnvironmentVip()
opv.option = op_l7
opv.environment = ev
opv.save()
finally:
try:
vro = VipRequestPortOptionVip.objects.filter(
optionvip=op_l7, vip_request_port=vrp)[0]
except:
vro = VipRequestPortOptionVip()
vro.optionvip = op_l7
vro.vip_request_port = vrp
vro.save()
# delete optionvip(l7 and l4) in port removed in old table
VipRequestPortOptionVip.objects.filter(
vip_request_port=vrp
).exclude(
optionvip__id__in=[op_l7.id, op_l4.id]
).delete()
# saving pools of port
try:
op_pt = OptionVip.objects.filter(
tipo_opcao=tipo_opcao,
nome_opcao_txt=nome_opcao_txt)[0]
try:
opv = OptionVipEnvironmentVip.objects.get(
option=op_pt,
environment=ev)
except:
opv = OptionVipEnvironmentVip()
opv.option = op_pt
opv.environment = ev
opv.save()
except:
op_pt = OptionVip()
op_pt.tipo_opcao = tipo_opcao
op_pt.nome_opcao_txt = nome_opcao_txt
op_pt.save()
opv = OptionVipEnvironmentVip()
opv.option = op_pt
opv.environment = ev
opv.save()
finally:
try:
vrpp = VipRequestPortPool.objects.filter(
server_pool=pool.server_pool, vip_request_port=vrp)[0]
except:
vrpp = VipRequestPortPool()
vrpp.server_pool = pool.server_pool
vrpp.vip_request_port = vrp
vrpp.optionvip = op_pt
vrpp.save()
except Exception, e:
log.error(e)
raise e
def new_to_old(vp):
from networkapi.api_vip_request.models import VipRequestDSCP
from networkapi.requisicaovips.models import DsrL3_to_Vip, \
RequisicaoVips, VipPortToPool
try:
vip_map = dict()
vip = RequisicaoVips()
vip.id = vp.id
vip.ip = vp.ipv4 if vp.ipv4 else None
vip.ipv6 = vp.ipv6 if vp.ipv6 else None
vip_map['ip'] = vp.ipv4 if vp.ipv4 else None
vip_map['ipv6'] = vp.ipv6 if vp.ipv6 else None
vip_map['finalidade'] = vp.environmentvip.finalidade_txt
vip_map['cliente'] = vp.environmentvip.cliente_txt
vip_map['ambiente'] = vp.environmentvip.ambiente_p44_txt
for vp_optionvip in vp.viprequestoptionvip_set.all():
if vp_optionvip.optionvip.tipo_opcao == u'Persistencia':
vip_map['persistencia'] = vp_optionvip.optionvip.nome_opcao_txt
if vp_optionvip.optionvip.tipo_opcao == u'timeout':
vip_map['timeout'] = vp_optionvip.optionvip.nome_opcao_txt
if vp_optionvip.optionvip.tipo_opcao == u'cache':
vip_map['cache'] = vp_optionvip.optionvip.nome_opcao_txt
if vp_optionvip.optionvip.tipo_opcao == u'Retorno de trafego':
vip_map['trafficreturn'] = vp_optionvip.optionvip.id
vip.trafficreturn = vp_optionvip.optionvip
vip_map['host'] = vp.name
vip_map['areanegocio'] = vp.business
vip_map['nome_servico'] = vp.service
vip_map['vip_ports_to_pools'] = list()
ports = vp.viprequestport_set.all()
# delete old ports
pools_current = VipPortToPool.get_by_vip_id(vip.id)
pools_ids = [pool.id for pool in pools_current]
ports_ids = [pt.id for pt in ports]
ids_to_del = list(set(pools_ids) - set(ports_ids))
pools_current.filter(id__in=ids_to_del).delete()
vip.vip_criado = vp.created
vip.validado = True
vip.save()
for port in ports:
pools = port.viprequestportpool_set.all()
for pool in pools:
if pool.optionvip.nome_opcao_txt in (u'default_vip'):
vip_port = {
'id': port.id,
'requisicao_vip': vip,
'server_pool': pool.server_pool,
'port_vip': port.port,
'identifier': port.identifier,
}
vip_map['vip_ports_to_pools'].append(vip_port)
vip_port_obj = VipPortToPool(**vip_port)
vip_port_obj.save()
if int(vip_map['trafficreturn']) == 48:
dsrl3 = VipRequestDSCP.objects.get(vip_request=vp)
try:
vp_dsrl3 = DsrL3_to_Vip.get_by_vip_id(vip.id)
except:
vp_dsrl3 = DsrL3_to_Vip()
vp_dsrl3.requisicao_vip_id = vip.id
vp_dsrl3.id_dsrl3 = dsrl3.dscp
vp_dsrl3.save()
else:
try:
vp_dsrl3 = DsrL3_to_Vip.get_by_vip_id(vip.id)
vp_dsrl3.delete()
except:
pass
vip.set_new_variables(vip_map)
vip.save()
except Exception, e:
log.error(e)
raise e
def get_by_pk(pk):
"""
Get Vip Request By Pk
:param pk: Identifier For Vip Request
:return: Dict
"""
if not is_valid_int_greater_zero_param(pk):
raise exceptions.InvalidIdVipRequestException()
vip_request = RequisicaoVips.objects.get(id=pk)
data = vip_request.variables_to_map()
data['id'] = vip_request.id
data['validado'] = convert_boolean_to_int(vip_request.validado)
data['vip_criado'] = convert_boolean_to_int(vip_request.vip_criado)
data['id_ip'] = vip_request.ip_id
data['id_ipv6'] = vip_request.ipv6_id
data['id_healthcheck_expect'] = vip_request.healthcheck_expect_id
data['l7_filter'] = vip_request.l7_filter
data['rule_id'] = vip_request.rule_id
data['trafficreturn'] = vip_request.trafficreturn.nome_opcao_txt
data['dsrl3'] = 999
try:
dsrl3_to_vip_obj = DsrL3_to_Vip.get_by_vip_id(vip_request.id)
data['dsrl3'] = dsrl3_to_vip_obj.id_dsrl3
except ObjectDoesNotExist:
pass
# data['dsrl3'] = '0'
pools = []
vip_to_ports_query = VipPortToPool.objects.filter(
requisicao_vip=vip_request)
for vip_port in vip_to_ports_query:
pools_members = []
server_pool = vip_port.server_pool
pool_raw = model_to_dict(server_pool)
pool_raw['port_vip'] = vip_port.port_vip
pool_raw['port_vip_id'] = vip_port.id
for pool_member in server_pool.serverpoolmember_set.all():
pools_member_raw = model_to_dict(pool_member)
ipv4 = pool_member.ip
ipv6 = pool_member.ipv6
ip_equipment_set = ipv4 and ipv4.ipequipamento_set or ipv6 and ipv6.ipv6equipament_set
ip_equipment_obj = ip_equipment_set.select_related(
'ip').uniqueResult()
healthcheck_type = pool_member.healthcheck and pool_member.healthcheck.healthcheck_type or ''
pools_member_raw['healthcheck'] = {
'healthcheck_type': healthcheck_type}
pools_member_raw[
'equipment_name'] = ip_equipment_obj.equipamento.nome
ip_formatted = ip_equipment_obj.ip.ip_formated
if ipv4:
pools_member_raw['ip'] = {'ip_formated': ip_formatted}
else:
pools_member_raw['ipv6'] = {'ip_formated': ip_formatted}
pools_members.append(pools_member_raw)
pool_raw['server_pool_members'] = pools_members
pools.append(pool_raw)
data['pools'] = pools
return data
def update(request, pk):
"""
Update Vip Request
:param request:
:param pk: Identifier Vip Request
:return: Data Serialized Post Update
"""
data = request.DATA
user = request.user
if not is_valid_int_greater_zero_param(pk):
raise exceptions.InvalidIdVipRequestException()
vip_ports = data.get('vip_ports_to_pools')
req_vip_serializer = RequestVipSerializer(
data=data
)
if not req_vip_serializer.is_valid():
log.error(req_vip_serializer.errors)
raise api_exceptions.ValidationException()
# test if request exists
RequisicaoVips.objects.get(pk=pk)
with distributedlock(LOCK_VIP % pk):
obj_req_vip = req_vip_serializer.object
# compatibility issues
if obj_req_vip.trafficreturn is None:
obj_req_vip.trafficreturn = RequisicaoVips.objects.get(
pk=pk).trafficreturn
obj_req_vip.id = int(pk)
obj_req_vip.filter_valid = True
obj_req_vip.validado = False
set_l7_filter_for_vip(obj_req_vip)
obj_req_vip.set_new_variables(data)
old_trafficreturn = RequisicaoVips.objects.get(pk=pk).trafficreturn
if old_trafficreturn.id != obj_req_vip.trafficreturn.id:
if obj_req_vip.trafficreturn.nome_opcao_txt == 'DSRL3':
dsrl3_to_vip_obj = DsrL3_to_Vip()
dsrl3_to_vip_obj.get_dsrl3(obj_req_vip, user)
else:
try:
dsrl3_to_vip_obj = DsrL3_to_Vip.get_by_vip_id(
obj_req_vip.id)
dsrl3_to_vip_obj.delete(user)
except ObjectDoesNotExist:
pass
obj_req_vip.save()
vip_port_serializer = VipPortToPoolSerializer(
data=vip_ports, many=True)
if not vip_port_serializer.is_valid():
raise api_exceptions.ValidationException(
'Invalid Port Vip To Pool')
vip_port_to_pool_pks = [port['id']
for port in vip_ports if port.get('id')]
vip_port_to_pool_to_remove = VipPortToPool.objects.filter(
requisicao_vip=obj_req_vip
).exclude(
id__in=vip_port_to_pool_pks
)
# valid if pools member can linked by environment/environment vip
# relationship rule
server_pool_ips_can_associate_with_vip_request(
obj_req_vip, vip_port_to_pool_to_remove)
for v_port_to_del in vip_port_to_pool_to_remove:
v_port_to_del.delete()
for vip_port in vip_ports:
vip_port_obj = VipPortToPool()
vip_port_obj.id = vip_port.get('id')
vip_port_obj.server_pool = ServerPool(
id=vip_port.get('server_pool'))
vip_port_obj.port_vip = vip_port.get('port_vip')
vip_port_obj.requisicao_vip = obj_req_vip
vip_port_obj.save()
# SYNC_VIP
syncs.old_to_new(obj_req_vip)
return req_vip_serializer.data
