def add_reals_before_script(port_vip, vip, ip, ip_type, priority, weight, port_real, user):
"""
Add real in VIP before execute script.
The script access the db when is executing.
This method is called if code returns 0.
"""
server_pool_member = ServerPoolMember()
server_pool = ServerPool.objects.get(
vipporttopool__port_vip=port_vip, vipporttopool__requisicao_vip=vip)
server_pool_member.prepare_and_save(
server_pool, ip, ip_type, priority, weight, port_real, user, True)
def add_reals_before_script(port_vip, vip, ip, ip_type, priority, weight, port_real, user):
"""
Add real in VIP before execute script.
The script access the db when is executing.
This method is called if code returns 0.
"""
server_pool_member = ServerPoolMember()
server_pool = ServerPool.objects.get(
vipporttopool__port_vip=port_vip, vipporttopool__requisicao_vip=vip)
server_pool_member.prepare_and_save(
server_pool, ip, ip_type, priority, weight, port_real, user, True)
def create_pool_member(self):
pool = self.create_server_pool_model()
member = ServerPoolMember(server_pool=pool,
identifier='member_1',
ip=self.create_ipv4(),
priority=1,
weight=0,
limit=pool.default_limit,
port_real=8080)
member.equipment = Equipamento(
id=1, nome="l-59c0df40-624d-4174-ad7e-a67e54bb3ced")
return member
def create_pool_member(self):
pool = self.create_server_pool_model()
member = ServerPoolMember(
server_pool=pool,
identifier='member_1',
ip=self.create_ipv4(),
priority=1,
weight=0,
limit=pool.default_limit,
port_real=8080
)
member.equipment = Equipamento(id = 1, nome = "l-59c0df40-624d-4174-ad7e-a67e54bb3ced")
return member
def save_server_pool_member(user, pool, list_server_pool_member):
list_pool_member = list()
old_priorities_list = list()
pool_members_to_be_removed = get_pool_members_to_be_removed(
list_server_pool_member)
remove_pool_members(pool_members_to_be_removed, pool, user)
if list_server_pool_member:
apply_new_priorities = False
for dic in list_server_pool_member:
ip_object, ipv6_object = get_ip_objects(dic)
pool_member_id = dic['id_pool_member']
if pool_member_id:
pool_member = ServerPoolMember.objects.get(id=pool_member_id)
old_member_priority = pool_member.priority
old_priorities_list.append(old_member_priority)
update_pool_member(pool, pool_member, dic, ip_object,
ipv6_object, user)
if (old_member_priority != pool_member.priority
and pool.pool_created):
apply_new_priorities = True
else:
pool_member = ServerPoolMember()
update_pool_member(pool, pool_member, dic, ip_object,
ipv6_object, user)
pool_member.save()
old_priorities_list.append(dic['priority'])
# execute script to create real if pool already created
# commits transaction. Rolls back if script returns error
if pool.pool_created:
ip_id = ip_object and ip_object.id or ipv6_object and ipv6_object.id
deploy_pool_member_config(ip_id, pool.id, dic['port_real'],
pool_member, user)
list_pool_member.append(pool_member)
# Applies new priority in pool - only 1 script run for all members
if (apply_new_priorities):
apply_priorities(list_pool_member, old_priorities_list, pool, user)
return list_pool_member
def save_server_pool_member(user, pool, list_server_pool_member):
list_pool_member = list()
old_priorities_list = list()
pool_members_to_be_removed = get_pool_members_to_be_removed(
list_server_pool_member)
remove_pool_members(pool_members_to_be_removed, pool, user)
if list_server_pool_member:
apply_new_priorities = False
for dic in list_server_pool_member:
ip_object, ipv6_object = get_ip_objects(dic)
pool_member_id = dic['id_pool_member']
if pool_member_id:
pool_member = ServerPoolMember.objects.get(id=pool_member_id)
old_member_priority = pool_member.priority
old_priorities_list.append(old_member_priority)
update_pool_member(
pool, pool_member, dic, ip_object, ipv6_object, user)
if(old_member_priority != pool_member.priority and pool.pool_created):
apply_new_priorities = True
else:
pool_member = ServerPoolMember()
update_pool_member(
pool, pool_member, dic, ip_object, ipv6_object, user)
pool_member.save()
old_priorities_list.append(dic['priority'])
# execute script to create real if pool already created
# commits transaction. Rolls back if script returns error
if pool.pool_created:
ip_id = ip_object and ip_object.id or ipv6_object and ipv6_object.id
deploy_pool_member_config(
ip_id, pool.id, dic['port_real'], pool_member, user)
list_pool_member.append(pool_member)
# Applies new priority in pool - only 1 script run for all members
if(apply_new_priorities):
apply_priorities(list_pool_member, old_priorities_list, pool, user)
return list_pool_member
def test_update_pool_member(self):
save_member_mock = patch(
'networkapi.requisicaovips.models.ServerPoolMember.save').start()
pool = ServerPool(id=1, default_limit=1)
pool_member = ServerPoolMember()
dict = {
'nome_equips': 'equip_name',
'weight': 1,
'priority': 1,
'port_real': 80
}
ip = Ip(id=1)
ipv6 = Ipv6(id=1)
update_pool_member(pool, pool_member, dict, ip, ipv6, self.user)
self.assertEquals(pool, pool_member.server_pool)
self.assertEquals(1, pool_member.limit)
self.assertEquals(ip, pool_member.ip)
self.assertEquals(ipv6, pool_member.ipv6)
self.assertEquals('equip_name', pool_member.identifier)
self.assertEquals(1, pool_member.weight)
self.assertEquals(1, pool_member.priority)
self.assertEquals(80, pool_member.port_real)
self.assertTrue(save_member_mock.called)
def test_validate_change_of_environment_given_pool_associated_to_one_or_more_pool_members(
self):
pool = self.mock_server_pool(created=False)
pool.serverpoolmember_set.exclude = lambda id__in: [ServerPoolMember()]
pool.vipporttopool_set.count = lambda: 0
with self.assertRaises(UpdateEnvironmentServerPoolMemberException):
validate_change_of_environment(1, pool)
def update_real_pool(request):
"""
- update real pool in eqpt
- update data pool in db
"""
pools = request.DATA.get("pools", [])
load_balance = {}
# valid data for save in DB and apply in eqpt
ps, sp = valid_to_save_reals_v2(pools)
for pool in pools:
ids = [p['id'] for p in pool['server_pool_members'] if p['id']]
db_members = ServerPoolMember.objects.filter(id__in=ids)
db_members_remove = ServerPoolMember.objects.filter(server_pool__id=pool['server_pool']['id']).exclude(id__in=ids)
db_members_id = [str(s.id) for s in db_members]
pools_members = list()
for pool_member in pool['server_pool_members']:
if not pool_member['ipv6']:
ip = pool_member['ip']['ip_formated']
else:
ip = pool_member['ipv6']['ip_formated']
if pool_member['id']:
member = db_members[db_members_id.index(str(pool_member['id']))]
if not member.ipv6:
ip_db = member.ip.ip_formated
else:
ip_db = member.ipv6.ip_formated
if member.port_real == pool_member['port_real'] and ip_db == ip:
pools_members.append({
'id': pool_member['id'],
'ip': ip,
'port': pool_member['port_real'],
'limit': pool_member['limit'],
'priority': pool_member['priority'],
'weight': pool_member['weight'],
})
else:
pools_members.append({
'id': None,
'ip': ip_db,
'port': member.port_real,
'remove': 1
})
pools_members.append({
'id': pool_member['id'],
'ip': ip,
'port': pool_member['port_real'],
'limit': pool_member['limit'],
'priority': pool_member['priority'],
'weight': pool_member['weight'],
'new': 1
})
else:
pools_members.append({
'id': None,
'ip': ip,
'port': pool_member['port_real'],
'limit': pool_member['limit'],
'priority': pool_member['priority'],
'weight': pool_member['weight'],
'new': 1
})
# members to remove
for member in db_members_remove:
if not member.ipv6:
ip_db = member.ip.ip_formated
else:
ip_db = member.ipv6.ip_formated
pools_members.append({
'id': member.id,
'ip': ip_db,
'port': member.port_real,
'remove': 1
})
# get eqpts associate with pool
equips = EquipamentoAmbiente.objects.filter(
ambiente__id=pool['server_pool']['environment']['id'],
equipamento__tipo_equipamento__tipo_equipamento=u'Balanceador')
equipment_list = [e.equipamento for e in equips]
if all_equipments_are_in_maintenance(equipment_list):
raise AllEquipmentsAreInMaintenanceException()
for e in equips:
eqpt_id = str(e.equipamento.id)
equipment_access = EquipamentoAcesso.search(
equipamento=e.equipamento.id,
protocolo="https"
).uniqueResult()
equipment = Equipamento.get_by_pk(e.equipamento.id)
plugin = PluginFactory.factory(equipment)
if not load_balance.get(eqpt_id):
load_balance[eqpt_id] = {
'plugin': plugin,
'fqdn': equipment_access.fqdn,
'user': equipment_access.user,
'password': equipment_access.password,
'pools': [],
}
load_balance[eqpt_id]['pools'].append({
'id': pool['server_pool']['id'],
'nome': pool['server_pool']['identifier'],
'lb_method': pool['server_pool']['lb_method'],
'healthcheck': pool['server_pool']['healthcheck'],
'action': pool['server_pool']['servicedownaction']['name'],
'pools_members': pools_members
})
# get ids from pools created
names = [sp[p].id for idx, p in enumerate(ps) if sp[p].pool_created]
environments = [sp[p].id for idx, p in enumerate(ps) if sp[p].pool_created]
# call plugin to change in load balance
for lb in load_balance:
lbe = [l for l in load_balance[lb]['pools'] if l['id'] in names if l['id'] in environments]
if len(lbe) > 0:
json = load_balance[lb]
json['pools'] = lbe
json['plugin'].updatePool(json)
# save pool in DB
for idx in sp:
idx = str(idx)
sp[idx].identifier = ps[idx]['server_pool']['identifier']
sp[idx].environment = Ambiente.objects.get(
id=ps[idx]['server_pool']['environment']['id'])
sp[idx].default_limit = ps[idx]['server_pool']['default_limit']
sp[idx].default_port = ps[idx]['server_pool']['default_port']
sp[idx].lb_method = ps[idx]['server_pool']['lb_method']
sp[idx].servicedownaction = OptionPool.objects.get(
id=ps[idx]['server_pool']['servicedownaction']['id'])
is_healthcheck_valid(ps[idx]['server_pool']['healthcheck'])
ps[idx]['server_pool']['healthcheck'] = ps[idx]['server_pool']['healthcheck']
sp[idx].healthcheck = get_or_create_healthcheck(
request.user,
ps[idx]['server_pool']['healthcheck']['healthcheck_expect'],
ps[idx]['server_pool']['healthcheck']['healthcheck_type'],
ps[idx]['server_pool']['healthcheck']['healthcheck_request'],
ps[idx]['server_pool']['healthcheck']['destination'],
ps[idx]['server_pool']['healthcheck']['identifier'])
sp[idx].save()
members_id = [p['id'] for p in pool['server_pool_members'] for pool in pools if p['id']]
pms = ServerPoolMember.objects.filter(id__in=members_id)
pms_delete = ServerPoolMember.objects.exclude(id__in=members_id).filter(server_pool__id__in=[pool['server_pool']['id'] for pool in pools])
members = dict()
for pool in pools:
for member in pool['server_pool_members']:
if member['id']:
members[str(member['id'])] = member
# update pool members
log.info(pools)
for pm in pms:
if members.get(str(pm.id)):
pm.port_real = members.get(str(pm.id))['port_real']
pm.priority = members.get(str(pm.id))['priority']
pm.weight = members.get(str(pm.id))['weight']
pm.limit = members.get(str(pm.id))['limit']
pm.save()
# delete pool members
for pm in pms_delete:
pm.delete()
# create new pool members
members = [p for p in pool['server_pool_members'] for pool in pools if not p['id']]
for member in members:
pm = ServerPoolMember()
pm.server_pool_id = member['server_pool']['id']
pm.limit = member['limit']
if member['ip']:
pm.ip_id = member['ip']['id']
if member['ipv6']:
pm.ipv6_id = member['ipv6']['id']
pm.identifier = member['identifier']
pm.weight = member['weight']
pm.priority = member['priority']
pm.port_real = member['port_real']
pm.save()
# Save reals
# save_server_pool_member(request.user, sp, list_server_pool_member)
return {}
def _create_pool_member(members, pool):
"""Creates pool members"""
for member in members:
ip = Ip.get_by_pk(member['ip']['id']) if member['ip'] else None
ipv6 = Ipv6.get_by_pk(member['ipv6']['id']) if member['ipv6'] else None
identifier = ip.ip_formated if ip else ipv6.ip_formated
pool_member = ServerPoolMember()
pool_member.server_pool = pool
pool_member.ip = ip
pool_member.ipv6 = ipv6
pool_member.identifier = identifier
pool_member.weight = member['weight']
pool_member.priority = member['priority']
pool_member.port_real = member['port_real']
pool_member.member_status = member['member_status']
pool_member.limit = member['limit']
pool_member.save()
# vip with dsrl3 using pool
if pool.dscp:
mbs = pool_member.get_spm_by_eqpt_id(pool_member.equipment.id)
# check all the pools related to this pool vip request to filter
# dscp value
related_viprequestports = pool.vips[0].viprequestport_set.all()
vippools = [
p.viprequestportpool_set.all()[0].server_pool_id
for p in related_viprequestports
]
sps = ServerPool.objects.filter(serverpoolmember__in=mbs).exclude(
id__in=vippools)
dscps = [sp.dscp for sp in sps]
mb_name = '{}:{}'.format(
(ip.ip_formated if ip else ipv6.ip_formated),
member['port_real'])
if pool.dscp in dscps:
raise ValidationAPIException(
'DRSL3 Restriction: Pool Member {} cannot be insert'
' in Pool {}, because already in other pool'.format(
mb_name, pool.identifier))
if pool_member.port_real != pool.default_port:
raise ValidationAPIException(
'DRSL3 Restriction: Pool Member {} cannot have different'
' port of Pool {}'.format(mb_name, pool.identifier))
def save_server_pool_member(user, sp, list_server_pool_member):
list_pool_member = list()
old_priorities_list = list()
# Remove empty values from list
id_pool_member_noempty = [x['id_pool_member'] for x in list_server_pool_member if x['id_pool_member'] != '']
#exclue server pool member
del_smp = sp.serverpoolmember_set.exclude(id__in=id_pool_member_noempty)
if del_smp:
for obj in del_smp:
obj.delete(user)
#execute script remove real if pool already created
#commit transaction after each successful script call
if sp.pool_created:
command = settings.POOL_REAL_REMOVE % (obj.server_pool_id, obj.ip_id if obj.ip else obj.ipv6_id, obj.port_real)
code, _, _ = exec_script(command)
if code != 0:
raise exceptions.ScriptCreatePoolException()
transaction.commit()
if list_server_pool_member:
apply_new_priorities = False
for dic in list_server_pool_member:
#
ip_object = None
ipv6_object = None
if len(dic['ip']) <= 15:
ip_object = Ip.get_by_pk(dic['id'])
else:
ipv6_object = Ipv6.get_by_pk(dic['id'])
id_pool = sp.id
id_ip = ip_object and ip_object.id or ipv6_object and ipv6_object.id
port_ip = dic['port_real']
if dic['id_pool_member']:
spm = ServerPoolMember.objects.get(id=dic['id_pool_member'])
spm.server_pool = sp
spm.identifier = dic['nome_equips']
spm.ip = ip_object
spm.ipv6 = ipv6_object
spm.weight = dic['weight']
spm.limit = sp.default_limit
old_spm_priority = spm.priority
old_priorities_list.append(old_spm_priority)
spm.priority = dic['priority']
spm.port_real = dic['port_real']
spm.save(user)
if(old_spm_priority != spm.priority and sp.pool_created):
apply_new_priorities = True
else:
spm = ServerPoolMember(server_pool=sp, identifier=dic['nome_equips'], ip=ip_object, ipv6=ipv6_object,
priority=dic['priority'], weight=dic['weight'], limit=sp.default_limit,
port_real=dic['port_real'])
spm.save(user)
old_priorities_list.append(dic['priority'])
#execute script to create real if pool already created
#commits transaction. Rolls back if script returns error
if sp.pool_created:
transaction.commit()
#def prepare_and_save(self, server_pool, ip, ip_type, priority, weight, port_real, user, commit=False):
#spm.prepare_and_save(sp, ip_object, IP_VERSION.IPv4[1], dic['priority'], dic['weight'], dic['port_real'], user, True)
command = settings.POOL_REAL_CREATE % (id_pool, id_ip, port_ip)
code, _, _ = exec_script(command)
if code != 0:
spm.delete(user)
transaction.commit()
raise exceptions.ScriptCreatePoolException()
#if sp.healthcheck_id:
# spm.healthcheck = sp.healthcheck
list_pool_member.append(spm)
#Applies new priority in pool - only 1 script run for all members
if(apply_new_priorities):
transaction.commit()
command = settings.POOL_MEMBER_PRIORITIES % (sp.id)
code, _, _ = exec_script(command)
if code != 0:
for i in len(old_priorities_list):
list_pool_member[i].priority = old_priorities_list[i]
list_pool_member[i].save(user)
transaction.commit()
raise exceptions.ScriptAlterPriorityPoolMembersException()
return list_pool_member
def administrate_real(self,
user,
vip_id,
equip_id,
ip_id,
operation,
network_version,
port_vip=None,
port_real=None):
# Valid VIP ID
if not is_valid_int_greater_zero_param(vip_id):
self.log.error(u'The vip_id parameter is not a valid value: %s.',
vip_id)
raise InvalidValueError(None, 'vip_id', vip_id)
# Valid Equipament ID
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(u'The equip_id parameter is not a valid value: %s.',
equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
# Valid IP ID
if not is_valid_int_greater_zero_param(ip_id):
self.log.error(u'The ip_id parameter is not a valid value: %s.',
ip_id)
raise InvalidValueError(None, 'ip_id', ip_id)
# Valid operation
if operation not in ['add', 'del', 'ena', 'dis', 'chk']:
self.log.error(
u'The operation parameter is not a valid value: %s.',
operation)
raise InvalidValueError(None, 'operation', operation)
# Valid network version
if network_version not in ['v4', 'v6']:
self.log.error(
u'The network_version parameter is not a valid value: %s.',
network_version)
raise InvalidValueError(None, 'network_version', network_version)
# User permission
if (operation == 'chk'):
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
else:
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION, None, equip_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# new_call = True - New calls for Add/Del/Enable/Disable/Check with new params (Port Vip and Port Real)
# new_call = False = Old calls for compatibility
new_call = False
if port_vip is not None and port_real is not None:
# Valid ports
if not is_valid_int_greater_zero_param(port_vip):
self.log.error(
u'The port_vip parameter is not a valid value: %s.',
port_vip)
raise InvalidValueError(None, 'port_vip', port_vip)
if not is_valid_int_greater_zero_param(port_real):
self.log.error(
u'The port_vip parameter is not a valid value: %s.',
port_real)
raise InvalidValueError(None, 'port_real', port_real)
new_call = True
# Find Request VIP by ID to check if it exist
vip = RequisicaoVips.get_by_pk(vip_id)
# Get variables
variables_map = vip.variables_to_map()
# Valid variables
# vip.set_variables(variables_map)
evip = EnvironmentVip.get_by_values(variables_map.get('finalidade'),
variables_map.get('cliente'),
variables_map.get('ambiente'))
# Valid network_version - IPv4
if network_version == IP_VERSION.IPv4[0]:
# Find IpEquipamento to check if it exist
IpEquip = IpEquipamento().get_by_ip_equipment(ip_id, equip_id)
real_name = IpEquip.equipamento.nome
end_ip = '%s.%s.%s.%s' % (IpEquip.ip.oct1, IpEquip.ip.oct2,
IpEquip.ip.oct3, IpEquip.ip.oct4)
# Valid Real
RequisicaoVips.valid_real_server(end_ip, IpEquip.equipamento, evip,
False)
# Valid network_version - IPv6
elif network_version == IP_VERSION.IPv6[0]:
# Find Ipv6Equipament to check if it exist
Ipv6Equip = Ipv6Equipament().get_by_ip_equipment(ip_id, equip_id)
real_name = Ipv6Equip.equipamento.nome
end_ip = '%s:%s:%s:%s:%s:%s:%s:%s' % (
Ipv6Equip.ip.block1, Ipv6Equip.ip.block2, Ipv6Equip.ip.block3,
Ipv6Equip.ip.block4, Ipv6Equip.ip.block5, Ipv6Equip.ip.block6,
Ipv6Equip.ip.block7, Ipv6Equip.ip.block8)
# Valid Real
RequisicaoVips.valid_real_server(end_ip, Ipv6Equip.equipamento,
evip, False)
if (operation == 'chk'):
if IP_VERSION.IPv4[0] == network_version:
if new_call:
command = VIP_REALS_v4_CHECK % (vip_id, ip_id, port_real,
port_vip)
else:
command = VIP_REAL_v4_CHECK % (vip_id, real_name, end_ip)
else:
if new_call:
command = VIP_REALS_v6_CHECK % (vip_id, ip_id, port_real,
port_vip)
else:
command = VIP_REAL_v6_CHECK % (vip_id, real_name, end_ip)
else:
with distributedlock(LOCK_VIP_IP_EQUIP %
(vip_id, ip_id, equip_id)):
if (operation == 'add'):
if IP_VERSION.IPv4[0] == network_version:
if new_call:
command = VIP_REALS_v4_CREATE % (
vip_id, ip_id, port_real, port_vip)
ServerPoolMember().save_specified_port(
vip_id, port_vip, IpEquip.ip,
IP_VERSION.IPv4[1], port_real, user)
else:
command = VIP_REAL_v4_CREATE % (vip_id, real_name,
end_ip)
ServerPoolMember().save_with_default_port(
vip_id, IpEquip.ip, IP_VERSION.IPv4[1], user)
else:
if new_call:
command = VIP_REALS_v6_CREATE % (
vip_id, ip_id, port_real, port_vip)
ServerPoolMember().save_specified_port(
vip_id, port_vip, Ipv6Equip.ip,
IP_VERSION.IPv6[1], port_real, user)
else:
command = VIP_REAL_v6_CREATE % (vip_id, real_name,
end_ip)
ServerPoolMember().save_with_default_port(
vip_id, Ipv6Equip.ip, IP_VERSION.IPv6[1], user)
elif (operation == 'del'):
if IP_VERSION.IPv4[0] == network_version:
if new_call:
command = VIP_REALS_v4_REMOVE % (
vip_id, ip_id, port_real, port_vip)
pool_members = ServerPoolMember.objects.filter(
ip=ip_id,
server_pool__vipporttopool__requisicao_vip__id=
vip_id,
server_pool__vipporttopool__port_vip=port_vip,
port_real=port_real)
[
pool_member.delete()
for pool_member in pool_members
]
else:
command = VIP_REAL_v4_REMOVE % (vip_id, real_name,
end_ip)
pool_members = ServerPoolMember.objects.filter(
ip=ip_id,
server_pool__vipporttopool__requisicao_vip__id=
vip_id)
[
pool_member.delete()
for pool_member in pool_members
]
else:
if new_call:
command = VIP_REALS_v6_REMOVE % (
vip_id, ip_id, port_real, port_vip)
pool_members = ServerPoolMember.objects.filter(
ipv6=ip_id,
server_pool__vipporttopool__requisicao_vip__id=
vip_id,
server_pool__vipporttopool__port_vip=port_vip,
port_real=port_real)
[
pool_member.delete()
for pool_member in pool_members
]
else:
command = VIP_REAL_v6_REMOVE % (vip_id, real_name,
end_ip)
pool_members = ServerPoolMember.objects.filter(
ipv6=ip_id,
server_pool__vipporttopool__requisicao_vip__id=
vip_id)
[
pool_member.delete()
for pool_member in pool_members
]
elif (operation == 'ena'):
if IP_VERSION.IPv4[0] == network_version:
if new_call:
command = VIP_REALS_v4_ENABLE % (
vip_id, ip_id, port_real, port_vip)
else:
command = VIP_REAL_v4_ENABLE % (vip_id, real_name,
end_ip)
else:
if new_call:
command = VIP_REALS_v6_ENABLE % (
vip_id, ip_id, port_real, port_vip)
else:
command = VIP_REAL_v6_ENABLE % (vip_id, real_name,
end_ip)
elif (operation == 'dis'):
if IP_VERSION.IPv4[0] == network_version:
if new_call:
command = VIP_REALS_v4_DISABLE % (
vip_id, ip_id, port_real, port_vip)
else:
command = VIP_REAL_v4_DISABLE % (vip_id, real_name,
end_ip)
else:
if new_call:
command = VIP_REALS_v6_DISABLE % (
vip_id, ip_id, port_real, port_vip)
else:
command = VIP_REAL_v6_DISABLE % (vip_id, real_name,
end_ip)
self.log.info(command)
# Execute script
code, stdout, stderr = exec_script(command)
self.log.info(stdout)
map = dict()
success_map = dict()
# Return XML
if code == 0:
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {'stdout': stdout, 'stderr': stderr}
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
elif code == 12:
success_map['codigo'] = '0'
success_map['descricao'] = {'stdout': '0', 'stderr': ''}
map['sucesso'] = success_map
self.rollback_changes(operation, new_call, network_version, vip_id,
ip_id, port_real, port_vip, real_name,
end_ip, user)
return self.response(dumps_networkapi(map))
else:
self.rollback_changes(operation, new_call, network_version, vip_id,
ip_id, port_real, port_vip, real_name,
end_ip, user)
return self.response_error(2, stdout + stderr)
