def handle_get(self, request, user, *args, **kwargs):
"""Validate L7 filter
URLs: /vip/l7/<id_vip>/validate/
"""
try:
if not has_perm(user, AdminPermission.VIP_VALIDATION,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
self.log.info("Validate L7 filter to VIP")
id_vip = kwargs.get('id_vip')
# Valid Vip ID
if not is_valid_int_greater_zero_param(id_vip):
self.log.error(
u'The vip_id parameter is not a valid value: %s.', id_vip)
raise InvalidValueError(None)
vip = RequisicaoVips.get_by_pk(id_vip)
with distributedlock(LOCK_VIP % id_vip):
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'L7 filter can not be changed because VIP has not yet been created.'
)
raise RequestVipsNotBeenCreatedError(None)
vip.filter_valid = True
vip.save()
map = dict()
map['sucesso'] = 'sucesso'
return self.response(dumps_networkapi(map))
except UserNotAuthorizedError:
return self.not_authorized()
def handle_get(self, request, user, *args, **kwargs):
"""Rollback of the filter
URLs: /vip/l7/<id_vip>/rollback/
"""
self.log.info('Applies the last working filter to VIP')
try:
id_vip = kwargs.get('id_vip')
# User is authorized
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Vip ID
if not is_valid_int_greater_zero_param(id_vip):
self.log.error(
u'The vip_id parameter is not a valid value: %s.', id_vip)
raise InvalidValueError(None)
# Get VIP data
vip = RequisicaoVips.get_by_pk(id_vip)
with distributedlock(LOCK_VIP % id_vip):
# backup do vip
vip_old = clone(vip)
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Filter can not be applied because VIP has not been created yet.'
)
raise RequestVipsNotBeenCreatedError(None)
# salva data do rollback, rollback para aplicado, passa o
# aplicado para l7
vip.applied_l7_datetime = datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
# Set Applied With Rollback
vip.filter_applied = vip_old.filter_rollback
vip.rule_applied = vip_old.rule_rollback
# Set Rollback With Applied
vip.filter_rollback = vip_old.filter_applied
vip.rule_rollback = vip_old.rule_applied
vip.save(user, commit=True)
# roda script
command = 'gerador_vips -i %d --l7_filter_current' % vip.id
code, stdout, stderr = exec_script(command)
# code 0 = executou com sucesso
if code == 0:
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {
'stdout': stdout,
'stderr': stderr
}
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
# pega os dados anteriores e os salva no banco
vip_old.save(user, commit=True)
return self.response_error(2, stdout + stderr)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to add block in vip rule.
URLs: /vip/add_block/<id_vip>/<id_block>/<override>
"""
self.log.info('Add block in rule vip')
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Business Validations
id_vip = kwargs.get('id_vip')
id_block = kwargs.get('id_block')
override = kwargs.get('override')
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)
if not is_valid_int_greater_zero_param(id_block):
self.log.error(u'Parameter id_block is invalid. Value: %s.',
id_block)
raise InvalidValueError(None, 'id_block', id_block)
if not is_valid_boolean_param(override, False):
self.log.error(u'Parameter override is invalid. Value: %s.',
override)
raise InvalidValueError(None, 'override', override)
else:
override = convert_string_or_int_to_boolean(override)
vip = RequisicaoVips.get_by_pk(id_vip)
vip_map = vip.variables_to_map()
host = vip_map['host']
rule_applied = vip.rule_applied
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Block can not added because VIP has not been created yet.'
)
raise RequestVipsNotBeenCreatedError(None)
###################################################
# Vip Request has a rule applied #
###################################################
if rule_applied:
block_in_rules = self.insert_block_in_rule(
id_block, rule_applied)
# create new rule
# make a copy
new_rule_content = copy.copy(rule_applied)
# remove the rule if is a vip rule and this rule is not applied
if vip.rule:
if rule_applied != vip.rule and vip.rule.vip:
vip.rule.delete()
# duplicate rule with new block
new_rule_content.id = None
new_rule_content.vip = vip
count_rule_vip = Rule.objects.filter(vip=vip).count()
diff_name = '(' + str(count_rule_vip) + \
')' if count_rule_vip else ''
new_rule_content.name = 'regra_' + host + diff_name
new_rule_content.save(user, force_insert=True)
###################################################
# Vip Request hasn't a rule applied #
###################################################
else:
block_in_rules, environment = self.generate_rule_contents(
vip, id_block)
# create new rule
new_rule_content = Rule()
count_rule_vip = Rule.objects.filter(vip=vip).count()
diff_name = '(' + str(count_rule_vip) + \
')' if count_rule_vip else ''
new_rule_content.name = 'regra_' + host + diff_name
new_rule_content.vip = vip
new_rule_content.environment = environment
new_rule_content.save()
new_content = '\n'.join(d['content'] for d in block_in_rules)
# save contents with new rule
for i in range(len(block_in_rules)):
rule_content = RuleContent()
rule_content.content = block_in_rules[i]['content']
rule_content.order = i
rule_content.rule = new_rule_content
rule_content.save()
if override or not vip.l7_filter:
# update filter and rule with new block
vip.l7_filter = new_content
vip.rule = new_rule_content
vip.filter_valid = True
vip.save()
else:
self.log.error(
u'Block can not be added because there is already a rule to apply, and the value of zero is overwritten.'
)
raise AddBlockOverrideNotDefined(None)
success_map = dict()
success_map['codigo'] = 0
success_map['descricao'] = u'Bloco incluído com sucesso'
return self.response(dumps_networkapi({'sucesso': success_map}))
except VipRequestBlockAlreadyInRule, e:
self.log.error(e.message)
return self.response_error(361)
def handle_put(self, request, user, *args, **kwargs):
"""
Handles PUT requests to change the VIP's persistence.
URL: vip/<id_vip>/persistence
"""
self.log.info("Change VIP's persistence")
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Vip ID
vip_id = kwargs.get('id_vip')
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)
# Existing Vip ID
vip = RequisicaoVips.get_by_pk(vip_id)
with distributedlock(LOCK_VIP % vip_id):
vip_old = clone(vip)
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Persistence can not be changed because VIP has not yet been created.'
)
raise RequestVipsNotBeenCreatedError(None)
# Vip equipments permission
if vip.ip is not None:
for ip_equipment in vip.ip.ipequipamento_set.all():
if not has_perm(
user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION, None,
ip_equipment.equipamento_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.'
)
raise EquipmentGroupsNotAuthorizedError(None)
if vip.ipv6 is not None:
for ip_equipment in vip.ipv6.ipv6equipament_set.all():
if not has_perm(
user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION, None,
ip_equipment.equipamento_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.'
)
raise EquipmentGroupsNotAuthorizedError(None)
# Business Validations
# Load XML data
xml_map, attrs_map = loads(request.raw_post_data)
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'There is no value to the networkapi tag of XML request.'
)
vip_map = networkapi_map.get('vip')
if vip_map is None:
return self.response_error(
3, u'There is no value to the vip tag of XML request.')
# Get variables
variables_map = vip.variables_to_map()
# validation of persistence type is doing by set_variables
persistence = vip_map.get('persistencia', None)
variables_map['persistencia'] = persistence
# Set variables
vip.set_variables(variables_map)
# Save VIP
vip.save(user, commit=True)
# SYNC_VIP
old_to_new(vip)
# Executar script
# gerador_vips -i <ID_REQUISICAO> --healthcheck
command = 'gerador_vips -i %d --persistence' % vip.id
code, stdout, stderr = exec_script(command)
if code == 0:
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {
'stdout': stdout,
'stderr': stderr
}
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
vip_old.save(user, commit=True)
return self.response_error(2, stdout + stderr)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)
def handle_put(self, request, user, *args, **kwargs):
"""
Handles PUT requests to change the VIP's healthcheck.
URL: vip/<id_vip>/healthcheck
"""
self.log.info("Change VIP's healthcheck")
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Vip ID
vip_id = kwargs.get('id_vip')
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)
# Existing Vip ID
vip = RequisicaoVips.get_by_pk(vip_id)
with distributedlock(LOCK_VIP % vip_id):
vip_old = clone(vip)
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Healthcheck can not be changed because VIP has not yet been created.'
)
raise RequestVipsNotBeenCreatedError(None)
# Vip equipments permission
if vip.ip is not None:
for ip_equipment in vip.ip.ipequipamento_set.all():
if not has_perm(
user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION, None,
ip_equipment.equipamento_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.'
)
raise EquipmentGroupsNotAuthorizedError(None)
if vip.ipv6 is not None:
for ip_equipment in vip.ipv6.ipv6equipament_set.all():
if not has_perm(
user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION, None,
ip_equipment.equipamento_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.'
)
raise EquipmentGroupsNotAuthorizedError(None)
# Business Validations
# Load XML data
xml_map, attrs_map = loads(request.raw_post_data)
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'There is no value to the networkapi tag of XML request.'
)
vip_map = networkapi_map.get('vip')
if vip_map is None:
return self.response_error(
3, u'There is no value to the vip tag of XML request.')
# Get XML data
healthcheck_type = upper(str(vip_map['healthcheck_type']))
healthcheck = vip_map['healthcheck']
id_healthcheck_expect = vip_map['id_healthcheck_expect']
vars = vip.variables_to_map()
environment_vip = EnvironmentVip.get_by_values(
vars.get('finalidade'), vars.get('cliente'),
vars.get('ambiente'))
healthcheck_is_valid = RequisicaoVips.heathcheck_exist(
healthcheck_type, environment_vip.id)
# healthcheck_type exist'
if not healthcheck_is_valid:
self.log.error(
u'The healthcheck_type parameter not exist.')
raise InvalidValueError(
u'The healthcheck_type parameter not exist.',
'healthcheck_type', healthcheck_type)
# If healthcheck_type is not HTTP id_healthcheck_expect and
# healthcheck must be None
if healthcheck_type != 'HTTP':
if not (id_healthcheck_expect is None
and healthcheck is None):
msg = u'The healthcheck_type parameter is %s, then healthcheck and id_healthcheck_expect must be None.' % healthcheck_type
self.log.error(msg)
raise InvalidValueError(msg)
# return self.response_error(276)
# If healthcheck_type is 'HTTP' id_healthcheck_expect and
# healthcheck must NOT be None
elif healthcheck_type == 'HTTP':
if id_healthcheck_expect is None or healthcheck is None:
msg = u'The healthcheck_type parameter is HTTP, then healthcheck and id_healthcheck_expect must NOT be None.'
self.log.error(msg)
raise InvalidValueError(msg)
else:
try:
# Valid healthcheck_expect ID
if not is_valid_int_greater_zero_param(
id_healthcheck_expect):
self.log.error(
u'The id_healthcheck_expect parameter is not a valid value: %s.',
id_healthcheck_expect)
raise InvalidValueError(
None, 'id_healthcheck_expect',
id_healthcheck_expect)
# Find healthcheck_expect by ID to check if it
# exist
healthcheck_expect = HealthcheckExpect.get_by_pk(
id_healthcheck_expect)
# Check if healthcheck is a string
if not isinstance(healthcheck, basestring):
msg = u'The healthcheck must be a string.'
self.log.error(msg)
raise InvalidValueError(
msg, 'healthcheck', healthcheck)
except HealthcheckExpectNotFoundError:
msg = u'The id_healthcheck_expect parameter does not exist.'
self.log.error(msg)
raise InvalidValueError(msg,
'id_healthcheck_expect',
id_healthcheck_expect)
# Business Rules
# Get variables
variables_map = vip.variables_to_map()
# Valid variables
vip.set_variables(variables_map)
# Set healthcheck_type
variables_map['healthcheck_type'] = healthcheck_type
# If healthcheck_type is HTTP
if healthcheck_type == 'HTTP':
# Set healthcheck
variables_map['healthcheck'] = healthcheck
# Set id_healthcheck_expect
vip.healthcheck_expect = healthcheck_expect
else:
# Set healthcheck to None
variables_map['healthcheck'] = None
# Set id_healthcheck_expect to None
vip.healthcheck_expect = None
# Set variables
vip.set_variables(variables_map)
# Save VIP
vip.save(user, commit=True)
# Executar script
# Put old call to work with new pool features
# This call is deprecated
server_pools = ServerPool.objects.filter(
vipporttopool__requisicao_vip=vip)
if healthcheck is None:
healthcheck = ''
if id_healthcheck_expect is None:
healthcheck_expect = ''
else:
healthcheck_expect = healthcheck_expect.expect_string
healthcheck_identifier = ''
healthcheck_destination = '*:*'
hc = get_or_create_healthcheck(user, healthcheck_expect,
healthcheck_type, healthcheck,
healthcheck_destination,
healthcheck_identifier)
# Applies new healthcheck in pool
# Todo - new method
old_healthchecks = []
for sp in server_pools:
old_healthchecks.append(sp.healthcheck)
sp.healthcheck = hc
sp.save(user, commit=True)
# gerador_vips -i <ID_REQUISICAO> --healthcheck
command = 'gerador_vips -i %d --healthcheck' % vip.id
code, stdout, stderr = exec_script(command)
if code == 0:
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {
'stdout': stdout,
'stderr': stderr
}
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
old_healthchecks.reverse()
for sp in server_pools:
sp.healthcheck = old_healthchecks.pop()
sp.save(user, commit=True)
vip_old.save(user, commit=True)
return self.response_error(2, stdout + stderr)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)
def handle_put(self, request, user, *args, **kwargs):
"""Treat PUT requests to change reals_priority list of VIP.
URLs: /vip/<id_vip>/priority/
"""
self.log.info("Change list the reals_priority to VIP")
try:
vip_id = kwargs.get('id_vip')
# Load XML data
xml_map, attrs_map = loads(request.raw_post_data,
['reals_priority'])
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'There is no value to the networkapi tag of XML request.'
)
vip_map = networkapi_map.get('vip')
if vip_map is None:
return self.response_error(
3, u'There is no value to the vip tag of XML request.')
# User permission
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(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 reals_prioritys
reals_prioritys_map = vip_map.get('reals_prioritys')
if (reals_prioritys_map is not None):
reals_priority_map = reals_prioritys_map.get('reals_priority')
if (reals_priority_map is not None):
# Valid values of reals_priority
for reals_priority in reals_priority_map:
if not is_valid_int_greater_equal_zero_param(
reals_priority):
self.log.error(
u'The reals_priority parameter is not a valid value: %s.',
reals_priority)
raise InvalidValueError(None, 'reals_priority',
reals_priority)
if len(reals_priority_map) > 0:
vip_map = RequisicaoVips.is_valid_values_reals_priority(
reals_priority_map)
else:
self.log.error(
u'The reals_priority_map parameter is not a valid value: %s.',
reals_priority_map)
raise InvalidValueError(None, 'reals_priority_map',
reals_priority_map)
else:
self.log.error(
u'The reals_priority parameter is not a valid value: %s.',
reals_priority_map)
raise InvalidValueError(None, 'reals_priority',
reals_priority_map)
else:
self.log.error(
u'The reals_prioritys parameter is not a valid value: %s.',
reals_prioritys_map)
raise InvalidValueError(None, 'reals_prioritys',
reals_prioritys_map)
# Existing Vip ID
vip = RequisicaoVips.get_by_pk(vip_id)
with distributedlock(LOCK_VIP % vip_id):
vip_old = clone(vip)
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Priority can not be changed because VIP has not yet been created.'
)
raise RequestVipsNotBeenCreatedError(None)
# Vip equipments permission
for ip_equipment in vip.ip.ipequipamento_set.all():
if not has_perm(
user, AdminPermission.VIP_CREATE_SCRIPT,
AdminPermission.WRITE_OPERATION, None,
ip_equipment.equipamento_id,
AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.'
)
raise EquipmentGroupsNotAuthorizedError(None)
variables_map = vip.variables_to_map()
# Valid list reals_server
"""if len(variables_map.get('reals').get('real')) != len(vip_map.get('reals_prioritys').get('reals_priority')):
self.log.error(u'List the Reals_priority is higher or lower than list the real_server.')
return self.response_error(272)"""
variables_map['reals_prioritys'] = vip_map.get(
'reals_prioritys')
vip.set_variables(variables_map)
vip.save(user, commit=True)
# gerador_vips -i <ID_REQUISICAO> --priority
command = 'gerador_vips -i %d --priority' % vip.id
code, stdout, stderr = exec_script(command)
if code == 0:
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {
'stdout': stdout,
'stderr': stderr
}
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
vip_old.save(user, commit=True)
return self.response_error(2, stdout + stderr)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)
def handle_put(self, request, user, *args, **kwargs):
"""Treat requests PUT change limit connections to VIP.
URLs: /vip/<id_vip>/maxcon/<maxcon>/
"""
self.log.info('Change limit connections to VIP')
try:
vip_id = kwargs.get('id_vip')
maxcon = kwargs.get('maxcon')
# User permission
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(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)
# Valid Maxcon
if not is_valid_int_greater_equal_zero_param(maxcon):
self.log.error(
u'The maxcon parameter is not a valid value: %s.', maxcon)
raise InvalidValueError(None)
# Existing Vip ID
vip = RequisicaoVips.get_by_pk(vip_id)
with distributedlock(LOCK_VIP % vip_id):
vip_old = clone(vip)
server_pools = ServerPool.objects.filter(
vipporttopool__requisicao_vip=vip)
server_pools_old = []
server_pools_members_old = []
for sp in server_pools:
server_pools_old.append(sp)
for spm in sp.serverpoolmember_set.all():
server_pools_members_old.append(spm)
# Vip must be created
if not vip.vip_criado:
self.log.error(
u'Maxcon can not be changed because VIP has not yet been created.')
raise RequestVipsNotBeenCreatedError(None)
# Vip equipments permission
if vip.ip is not None:
for ip_equipment in vip.ip.ipequipamento_set.all():
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT, AdminPermission.WRITE_OPERATION, None, ip_equipment.equipamento_id, AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.')
raise EquipmentGroupsNotAuthorizedError(None)
if vip.ipv6 is not None:
for ip_equipment in vip.ipv6.ipv6equipament_set.all():
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT, AdminPermission.WRITE_OPERATION, None, ip_equipment.equipamento_id, AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION):
self.log.error(
u'Groups of equipment registered with the IP of the VIP request is not allowed of acess.')
raise EquipmentGroupsNotAuthorizedError(None)
# Get variables
variables_map = vip.variables_to_map()
# Valid variables
vip.set_variables(variables_map)
# Valid real names and real ips of real server
if variables_map.get('reals') is not None:
evip = EnvironmentVip.get_by_values(variables_map.get(
'finalidade'), variables_map.get('cliente'), variables_map.get('ambiente'))
for real in variables_map.get('reals').get('real'):
ip_aux_error = real.get('real_ip')
equip_aux_error = real.get('real_name')
equip = Equipamento.get_by_name(equip_aux_error)
# Valid Real
RequisicaoVips.valid_real_server(
ip_aux_error, equip, evip)
# Valid reals_prioritys
variables_map, code = vip.valid_values_reals_priority(
variables_map)
if code is not None:
return self.response_error(329)
# Valid reals_weight
variables_map, code = vip.valid_values_reals_weight(
variables_map)
if code is not None:
return self.response_error(330)
# Valid ports
variables_map, code = vip.valid_values_ports(variables_map)
if code is not None:
return self.response_error(331)
variables_map['maxcon'] = maxcon
vip.set_variables(variables_map)
vip.save(user, commit=True)
# update server pool limits table
# Fix #27
server_pools = ServerPool.objects.filter(
vipporttopool__requisicao_vip=vip)
for sp in server_pools:
# If exists pool member, change default maxconn of pool and
# members
if(len(sp.serverpoolmember_set.all()) > 0):
# if(old_maxconn != sp.default_limit and
# sp.pool_created):
sp.default_limit = maxcon
sp.save(user, commit=True)
for serverpoolmember in sp.serverpoolmember_set.all():
serverpoolmember.limit = maxcon
serverpoolmember.save(user, commit=True)
# gerador_vips -i <ID_REQUISICAO> --maxconn
command = 'gerador_vips -i %d --maxconn' % vip.id
code, stdout, stderr = exec_script(command)
if code == 0:
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {
'stdout': stdout, 'stderr': stderr}
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
# TODO Check if is needed to update pool members separately
vip_old.save(user, commit=True)
for sp in server_pools_old:
sp.save(user, commit=True)
for spm in server_pools_members_old:
spm.save(user, commit=True)
return self.response_error(2, stdout + stderr)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)