def handle_post(self, request, user, *args, **kwargs):
"""Handles POST requests associate environment to ip config
URL: ipconfig/
"""
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
# 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'Não existe valor para a tag networkapi do XML de requisição.')
environment_map = networkapi_map.get('ambiente')
if environment_map is None:
return self.response_error(3, u'Não existe valor para a tag ambiente do XML de requisição.')
# Get XML data
id_environment = environment_map.get('id_environment')
id_ip_config = environment_map.get('id_ip_config')
# Valid environment
if not is_valid_int_greater_zero_param(id_environment):
raise InvalidValueError(None, 'id_environment', id_environment)
# Valid ip config
if not is_valid_int_greater_zero_param(id_ip_config):
raise InvalidValueError(None, 'id_ip_config', id_ip_config)
# Environment must exists
environment = Ambiente().get_by_pk(id_environment)
# Ip config must exists
ip_conf = IPConfig().get_by_pk(id_ip_config)
# Makes the relationship
config = ConfigEnvironment()
config.ip_config = ip_conf
config.environment = environment
config.save(user)
# Make return xml
conf_env_map = dict()
conf_env_map['id_config_do_ambiente'] = config.id
return self.response(dumps_networkapi({'config_do_ambiente': conf_env_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
'''Trata as requisições de PUT para inserir o relacionamento entre IP e Equipamento.
URL: ip/<id_ip>/equipamento/<id_equipamento>/$
'''
try:
ip_id = kwargs.get('id_ip')
equip_id = kwargs.get('id_equipamento')
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)
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)
Ip.get_by_pk(ip_id)
with distributedlock(LOCK_IP_EQUIPMENT % (ip_id, equip_id)):
ip_equipment = insert_ip_equipment(ip_id, equip_id, user)
ipequipamento_map = dict()
ipequipamento_map['id'] = ip_equipment.id
map = dict()
map['ip_equipamento'] = ipequipamento_map
return self.response(dumps_networkapi(map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""
Handles DELETE requests to create a relationship of Environment with EnvironmentVip.
URL: environment/<environment_id>/environmentvip/<environment_vip_id>/
"""
self.log.info("Remove a relationship of Environment with EnvironmentVip")
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(u"User does not have permission to perform the operation.")
raise UserNotAuthorizedError(None)
# Valid Environment
environment_id = kwargs.get("environment_id")
if not is_valid_int_greater_zero_param(environment_id):
self.log.error(u"The environment_id parameter is not a valid value: %s.", environment_id)
raise InvalidValueError(None, "environment_id", environment_id)
# Valid EnvironmentVip ID
environment_vip_id = kwargs.get("environment_vip_id")
if not is_valid_int_greater_zero_param(environment_vip_id):
self.log.error(u"The id_environment_vip parameter is not a valid value: %s.", environment_vip_id)
raise InvalidValueError(None, "environment_vip_id", environment_vip_id)
# Business Validations
# Existing Environment ID
environment = Ambiente.get_by_pk(environment_id)
# Existing EnvironmentVip ID
environment_vip = EnvironmentVip.get_by_pk(environment_vip_id)
# Business Rules
environment_environment_vip = EnvironmentEnvironmentVip().get_by_environment_environment_vip(
environment.id, environment_vip.id
)
server_pool_list = EnvironmentEnvironmentVip.get_server_pool_member_by_environment_environment_vip(
environment_environment_vip
)
# Valid integraty between environment/environmentvip related with reals
# if exists reals fot this environment then raise a exception
if server_pool_list:
raise EnvironmentEnvironmentServerPoolLinked({"environment": environment.name})
# Delete
environment_environment_vip.delete()
# Return nothing
return self.response(dumps_networkapi({}))
except UserNotAuthorizedError:
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove IP and Equipment relationship.
URL: ip/<id_ip>/equipamento/<id_equipamento>/$
"""
try:
ip_id = kwargs.get('id_ip')
equip_id = kwargs.get('id_equipamento')
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)
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)
Ip.get_by_pk(ip_id)
Equipamento.get_by_pk(equip_id)
with distributedlock(LOCK_IP_EQUIPMENT % (ip_id, equip_id)):
ipv4 = Ip.get_by_pk(ip_id)
equipament = Equipamento.get_by_pk(equip_id)
# Delete vlan's cache
destroy_cache_function([ipv4])
# delete equipment's cache
destroy_cache_function([equip_id], True)
server_pool_member_list = ServerPoolMember.objects.filter(
ip=ipv4)
if server_pool_member_list.count() != 0:
# IP associated with Server Pool
server_pool_name_list = set()
for member in server_pool_member_list:
item = '{}: {}'.format(
member.server_pool.id, member.server_pool.identifier)
server_pool_name_list.add(item)
server_pool_name_list = list(server_pool_name_list)
server_pool_identifiers = ', '.join(server_pool_name_list)
raise IpCantRemoveFromServerPool({'ip': mount_ipv4_string(ipv4), 'equip_name': equipament.nome, 'server_pool_identifiers': server_pool_identifiers},
'Ipv4 não pode ser disassociado do equipamento %s porque ele está sendo utilizando nos Server Pools (id:identifier) %s' % (equipament.nome, server_pool_identifiers))
remove_ip_equipment(ip_id, equip_id, user)
return self.response(dumps_networkapi({}))
except IpCantRemoveFromServerPool, e:
return self.response_error(385, e.cause.get('ip'), e.cause.get('equip_name'), e.cause.get('server_pool_identifiers'))
def handle_delete(self, request, user, *args, **kwargs):
"""
Handles DELETE requests to remove a relationship of OptionVip with EnvironmentVip.
URL: optionvip/<id_option_vip>/environmentvip/<id_environment_vip>/
"""
self.log.info("Remove a relationship of OptionVip with EnvironmentVip")
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.OPTION_VIP, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid OptionVip ID
option_vip_id = kwargs.get('id_option_vip')
if not is_valid_int_greater_zero_param(option_vip_id):
self.log.error(
u'The id_option_vip parameter is not a valid value: %s.', option_vip_id)
raise InvalidValueError(None, 'id_option_vip', option_vip_id)
# Valid EnvironmentVip ID
environment_vip_id = kwargs.get('id_environment_vip')
if not is_valid_int_greater_zero_param(environment_vip_id):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.', environment_vip_id)
raise InvalidValueError(
None, 'id_environment_vip', environment_vip_id)
# Business Validations
# Existing OptionVip ID
option_vip = OptionVip.get_by_pk(option_vip_id)
# Existing EnvironmentVip ID
environment_vip = EnvironmentVip.get_by_pk(environment_vip_id)
# Business Rules
# Find
opt_vip_env_vip = OptionVipEnvironmentVip().get_by_option_environment(
option_vip.id, environment_vip.id)
# Delete
opt_vip_env_vip.delete()
# Return nothing
return self.response(dumps_networkapi({}))
except UserNotAuthorizedError:
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to dissociate User and Group.
URL: usergroup/user/<id_user>/ugroup/<id_group>/dissociate/
"""
try:
self.log.info('Dissociate User and Group.')
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_user = kwargs.get('id_user')
id_group = kwargs.get('id_group')
# Valid ID User
if not is_valid_int_greater_zero_param(id_user):
self.log.error(
u'The id_user parameter is not a valid value: %s.', id_user)
raise InvalidValueError(None, 'id_user', id_user)
# Valid ID Group
if not is_valid_int_greater_zero_param(id_group):
self.log.error(
u'The id_group parameter is not a valid value: %s.', id_group)
raise InvalidValueError(None, 'id_group', id_group)
# Find User by ID to check if it exist
Usuario.get_by_pk(id_user)
# Find Group by ID to check if it exist
UGrupo.get_by_pk(id_group)
# Find UserGroup by ID to check if it exist
user_group = UsuarioGrupo.get_by_user_group(id_user, id_group)
with distributedlock(LOCK_USER_GROUP % (id_user, id_group)):
try:
# remove UserGroup
user_group.delete()
except Exception, e:
self.log.error(u'Failed to remove the UserGroup.')
raise GrupoError(e, u'Failed to remove the UserGroup.')
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para listar os direitos de grupo de usuários em grupo de equipamentos.
URLs: direitosgrupoequipamento/$
direitosgrupoequipamento/ugrupo/<id_grupo_usuario>/$
direitosgrupoequipamento/egrupo/<id_grupo_equipamento>/$
direitosgrupoequipamento/<id_direito>/$
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
return self.not_authorized()
map_list = []
right_id = kwargs.get('id_direito')
if not is_valid_int_greater_zero_param(right_id, False):
self.log.error(
u'The right_id parameter is not a valid value: %s.', right_id)
raise InvalidValueError(None, 'right_id', right_id)
if right_id is not None:
map_list.append(
self.__get_direito_map(DireitosGrupoEquipamento.get_by_pk(right_id)))
else:
ugroup = kwargs.get('id_grupo_usuario')
egroup = kwargs.get('id_grupo_equipamento')
if not is_valid_int_greater_zero_param(ugroup, False):
self.log.error(
u'The ugroup_id parameter is not a valid value: %s.', ugroup)
raise InvalidValueError(None, 'ugroup_id', ugroup)
if not is_valid_int_greater_zero_param(egroup, False):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.', egroup)
raise InvalidValueError(None, 'egroup_id', egroup)
if ugroup is not None:
UGrupo.get_by_pk(ugroup)
if egroup is not None:
EGrupo.get_by_pk(egroup)
rights = DireitosGrupoEquipamento.search(ugroup, None, egroup)
for right in rights:
map_list.append(self.__get_direito_map(right))
return self.response(dumps_networkapi({'direito_grupo_equipamento': map_list}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Treat PUT requests to associate Filter and TipoEquipamento.
URL: filter/<filter_id>/equiptype/<equiptype_id>
"""
try:
self.log.info('')
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs['id_filter']):
self.log.error(
u'Parameter id_filter is invalid. Value: %s.', kwargs['id_filter'])
raise InvalidValueError(None, 'id_filter', kwargs['id_filter'])
else:
# Check existence
fil = Filter().get_by_pk(kwargs['id_filter'])
if not is_valid_int_greater_zero_param(kwargs['id_equiptype']):
self.log.error(
u'Parameter id_equiptype is invalid. Value: %s.', kwargs['id_equiptype'])
raise InvalidValueError(
None, 'id_equiptype', kwargs['id_equiptype'])
else:
# Check existence
tp_equip = TipoEquipamento().get_by_pk(kwargs['id_equiptype'])
association = FilterEquipType()
association.filter = fil
association.equiptype = tp_equip
# Check existence
association.validate()
# Save association
association.save()
fil_et_map = dict()
fil_et_map['id'] = association.id
return self.response(dumps_networkapi({'equiptype_filter_xref': fil_et_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Trata uma requisição DELETE para excluir uma informação de acesso a equipamento
URL: /equipamentoacesso/id_equipamento/id_tipo_acesso/
"""
# Verifica acesso e obtém dados do request
try:
# Obtém argumentos passados na URL
id_equipamento = kwargs.get('id_equipamento')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_equipamento):
self.log.error(
u'The id_equipamento parameter is not a valid value: %s.', id_equipamento)
raise InvalidValueError(None, 'id_equipamento', id_equipamento)
id_tipo_acesso = kwargs.get('id_tipo_acesso')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_tipo_acesso):
self.log.error(
u'The id_tipo_acesso parameter is not a valid value: %s.', id_tipo_acesso)
raise InvalidValueError(None, 'id_tipo_acesso', id_tipo_acesso)
Equipamento.get_by_pk(id_equipamento)
TipoAcesso.get_by_pk(id_tipo_acesso)
# Após obtenção do id_equipamento podemos verificar a permissão
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
id_equipamento,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_EQUIPMENT_ACCESS % id_tipo_acesso):
# Remove a informação de acesso a equipamento
EquipamentoAcesso.remove(user, id_equipamento, id_tipo_acesso)
# Retorna response vazio em caso de sucesso
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to get Administrative Permission by the identifier.
URL: aperms/get/<id_perm>/
"""
try:
self.log.info("Get Administrative Permission by the identifier")
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_perm = kwargs.get('id_perm')
# Valid Administrative Permission ID
if not is_valid_int_greater_zero_param(id_perm):
self.log.error(
u'The id_perm parameter is not a valid value: %s.', id_perm)
raise InvalidValueError(None, 'id_perm', id_perm)
# Find Administrative Permission by ID to check if it exist
perm = PermissaoAdministrativa.get_by_pk(id_perm)
perms_map = dict()
perms_map['perm'] = model_to_dict(perm)
return self.response(dumps_networkapi(perms_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
try:
self.log.info('Get rules in Environment')
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_env = kwargs.get('id_env')
if not is_valid_int_greater_zero_param(id_env):
self.log.error(
u'The id_env parameter is not a valid value: %s.', id_env)
raise InvalidValueError(None, 'id_env', id_env)
Ambiente.objects.get(pk=id_env)
rules = Rule.objects.filter(environment=id_env, vip=None)
rule_list = []
for rule in rules:
rule_list.append(model_to_dict(rule))
return self.response(dumps_networkapi({'rules': rule_list}))
except InvalidValueError, e:
self.log.error(u'Parameter %s is invalid. Value: %s.', e.param,
e.value)
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to get Group Equipment.
URL: egroup/<id_egroup>/
"""
try:
self.log.info("Get Group Equipment by ID")
id_egroup = kwargs.get('id_egroup')
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Group Equipment ID
if not is_valid_int_greater_zero_param(id_egroup):
self.log.error(
u'The id_egroup parameter is not a valid value: %s.',
id_egroup)
raise InvalidValueError(None, 'id_egroup', id_egroup)
# Find Group Equipment by ID to check if it exist
egroup = EGrupo.get_by_pk(id_egroup)
egroup_map = dict()
egroup_map['group_equipament'] = model_to_dict(egroup)
return self.response(dumps_networkapi(egroup_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove Group User.
URL: ugroup/<id_ugroup>/
"""
try:
self.log.info('Remove Group User')
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_ugroup = kwargs.get('id_ugroup')
# Valid Group User ID
if not is_valid_int_greater_zero_param(id_ugroup):
self.log.error(
u'The id_ugroup parameter is not a valid value: %s.',
id_ugroup)
raise InvalidValueError(None, 'id_ugroup', id_ugroup)
# Find Group User by ID to check if it exist
ugroup = UGrupo.get_by_pk(id_ugroup)
with distributedlock(LOCK_GROUP_USER % id_ugroup):
ugroup.delete()
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Trata as requisições de DELETE para remover um grupo de equipamento.
URL: egrupo/<id_grupo>/
"""
try:
egroup_id = kwargs.get('id_grupo')
if not is_valid_int_greater_zero_param(egroup_id):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.',
egroup_id)
raise InvalidValueError(None, 'egroup_id', egroup_id)
egrp = EGrupo.get_by_pk(egroup_id)
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_GROUP_EQUIPMENT % egroup_id):
EGrupo.remove(user, egroup_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat GET requests to get a Filter by id.
URL: filter/get/<id_filter>/
"""
try:
self.log.info("Get Filter by id")
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs['id_filter']):
self.log.error(
u'Parameter id_filter is invalid. Value: %s.', kwargs['id_filter'])
raise InvalidValueError(None, 'id_filter', kwargs['id_filter'])
else:
# Check existence
fil = Filter().get_by_pk(kwargs['id_filter'])
filter_dict = model_to_dict(fil)
filter_dict['equip_types'] = list()
for fil_equip_type in fil.filterequiptype_set.all():
filter_dict['equip_types'].append(
model_to_dict(fil_equip_type.equiptype))
return self.response(dumps_networkapi({'filter': filter_dict}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat requests DELETE to remove Rule.
URL: rule/delete/<id_rule>/
"""
try:
self.log.info("Delete rule from an environment")
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_rule = kwargs.get('id_rule')
if not is_valid_int_greater_zero_param(id_rule):
self.log.error(
u'The id_rule parameter is not a valid value: %s.', id_rule)
raise InvalidValueError(None, 'id_rule', id_rule)
rule = Rule.objects.get(pk=id_rule)
rule.delete()
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Handle GET requests to get Environment by id.
URLs: /environment/id/<environment_id>/,
"""
try:
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT,
AdminPermission.READ_OPERATION):
return self.not_authorized()
environment_list = []
environment_id = kwargs.get('environment_id')
if not is_valid_int_greater_zero_param(environment_id):
self.log.error(
u'Parameter environment_id is invalid. Value: %s.',
environment_id)
raise InvalidValueError(None, 'environment_id', environment_id)
environment_list.append(
get_environment_map(Ambiente().get_by_pk(environment_id)))
return self.response(
dumps_networkapi({'ambiente': environment_list}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def _validate_network_type(self, network_type_id):
if not is_valid_int_greater_zero_param(network_type_id):
self.log.error(
u'The network_type_id parameter is invalid value: %s.',
network_type_id)
raise InvalidValueError(None, 'network_type_id', network_type_id)
def _validate_environment_id(self, id_environment):
if not is_valid_int_greater_zero_param(id_environment):
self.log.error(
u'The id_environment parameter is invalid value: %s.',
id_environment)
raise InvalidValueError(None, 'id_environment', id_environment)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove Filters.
URL: filter/<id_filter>/
"""
try:
self.log.info("Remove Filter")
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs['id_filter']):
self.log.error(
u'Parameter id_filter is invalid. Value: %s.', kwargs['id_filter'])
raise InvalidValueError(None, 'id_filter', kwargs['id_filter'])
else:
# Check existence
fil = Filter().get_by_pk(kwargs['id_filter'])
try:
# Remove filter and its relationships
fil.delete()
except Exception, e:
self.log.error(u'Failed to remove the filter.')
raise e
return self.response(dumps_networkapi({}))
def handle_delete(self, request, user, *args, **kwargs):
"""Trata as requisições de DELETE para remover direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/<id_direito>/
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
right_id = kwargs.get('id_direito')
if not is_valid_int_greater_zero_param(right_id, False):
self.log.error(
u'The right_id parameter is not a valid value: %s.',
right_id)
raise InvalidValueError(None, 'right_id', right_id)
DireitosGrupoEquipamento.get_by_pk(right_id)
with distributedlock(LOCK_GROUP_RIGHTS % right_id):
DireitosGrupoEquipamento.remove(user, right_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def generate_and_deploy_channel_config_sync(user, id_channel):
if not is_valid_int_greater_zero_param(id_channel):
raise exceptions.InvalidIdInterfaceException()
channel = PortChannel.get_by_pk(id_channel)
interfaces = channel.list_interfaces()
#group interfaces by equipment
equipment_interfaces = dict()
for interface in interfaces:
if interface.equipamento.id not in equipment_interfaces:
equipment_interfaces[interface.equipamento.id] = []
equipment_interfaces[interface.equipamento.id].append(interface)
files_to_deploy = {}
for equipment_id in equipment_interfaces.keys():
grouped_interfaces = equipment_interfaces[equipment_id]
file_to_deploy = _generate_config_file(grouped_interfaces)
files_to_deploy[equipment_id] = file_to_deploy
#TODO Deploy config file
#make separate threads
for equipment_id in files_to_deploy.keys():
lockvar = LOCK_INTERFACE_DEPLOY_CONFIG % (equipment_id)
equipamento = Equipamento.get_by_pk(equipment_id)
status_deploy = deploy_config_in_equipment_synchronous(files_to_deploy[equipment_id], equipamento, lockvar)
return status_deploy
def handle_delete(self, request, user, *args, **kwargs):
"""Treat requests DELETE to remove Rule.
URL: rule/delete/<id_rule>/
"""
try:
self.log.info('Delete rule from an environment')
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_rule = kwargs.get('id_rule')
if not is_valid_int_greater_zero_param(id_rule):
self.log.error(
u'The id_rule parameter is not a valid value: %s.', id_rule)
raise InvalidValueError(None, 'id_rule', id_rule)
rule = Rule.objects.get(pk=id_rule)
rule.delete()
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove Group User.
URL: ugroup/<id_ugroup>/
"""
try:
self.log.info('Remove Group User')
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_ugroup = kwargs.get('id_ugroup')
# Valid Group User ID
if not is_valid_int_greater_zero_param(id_ugroup):
self.log.error(
u'The id_ugroup parameter is not a valid value: %s.', id_ugroup)
raise InvalidValueError(None, 'id_ugroup', id_ugroup)
# Find Group User by ID to check if it exist
ugroup = UGrupo.get_by_pk(id_ugroup)
with distributedlock(LOCK_GROUP_USER % id_ugroup):
ugroup.delete()
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to get Group User.
URL: ugroup/get/<id_ugroup>/
"""
try:
self.log.info('Get Group User by ID')
id_ugroup = kwargs.get('id_ugroup')
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Group User ID
if not is_valid_int_greater_zero_param(id_ugroup):
self.log.error(
u'The id_ugroup parameter is not a valid value: %s.',
id_ugroup)
raise InvalidValueError(None, 'id_ugroup', id_ugroup)
# Find Group User by ID to check if it exist
ugroup = UGrupo.get_by_pk(id_ugroup)
ugroup_map = dict()
ugroup_map['user_group'] = model_to_dict(ugroup)
return self.response(dumps_networkapi(ugroup_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def generate_and_deploy_channel_config_sync(user, id_channel):
if not is_valid_int_greater_zero_param(id_channel):
raise exceptions.InvalidIdInterfaceException()
channel = PortChannel.get_by_pk(id_channel)
interfaces = channel.list_interfaces()
# group interfaces by equipment
equipment_interfaces = dict()
for interface in interfaces:
if interface.equipamento.id not in equipment_interfaces:
equipment_interfaces[interface.equipamento.id] = []
equipment_interfaces[interface.equipamento.id].append(interface)
files_to_deploy = {}
for equipment_id in equipment_interfaces.keys():
grouped_interfaces = equipment_interfaces[equipment_id]
file_to_deploy = _generate_config_file(grouped_interfaces)
files_to_deploy[equipment_id] = file_to_deploy
# TODO Deploy config file
# make separate threads
for equipment_id in files_to_deploy.keys():
lockvar = LOCK_INTERFACE_DEPLOY_CONFIG % (equipment_id)
equipamento = Equipamento.get_by_pk(equipment_id)
status_deploy = deploy_config_in_equipment_synchronous(
files_to_deploy[equipment_id], equipamento, lockvar)
return status_deploy
def handle_get(self, request, user, *args, **kwargs):
try:
self.log.info('Get rules in Environment')
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_env = kwargs.get('id_env')
if not is_valid_int_greater_zero_param(id_env):
self.log.error(
u'The id_env parameter is not a valid value: %s.', id_env)
raise InvalidValueError(None, 'id_env', id_env)
Ambiente.objects.get(pk=id_env)
rules = Rule.objects.filter(environment=id_env, vip=None)
rule_list = []
for rule in rules:
rule_list.append(model_to_dict(rule))
return self.response(dumps_networkapi({'rules': rule_list}))
except InvalidValueError, e:
self.log.error(
u'Parameter %s is invalid. Value: %s.', e.param, e.value)
return self.response_error(269, e.param, e.value)
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 get Group Equipment.
URL: egroup/<id_egroup>/
"""
try:
self.log.info('Get Group Equipment by ID')
id_egroup = kwargs.get('id_egroup')
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Group Equipment ID
if not is_valid_int_greater_zero_param(id_egroup):
self.log.error(
u'The id_egroup parameter is not a valid value: %s.', id_egroup)
raise InvalidValueError(None, 'id_egroup', id_egroup)
# Find Group Equipment by ID to check if it exist
egroup = EGrupo.get_by_pk(id_egroup)
egroup_map = dict()
egroup_map['group_equipament'] = model_to_dict(egroup)
return self.response(dumps_networkapi(egroup_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove Filters.
URL: filter/<id_filter>/
"""
try:
self.log.info('Remove Filter')
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs['id_filter']):
self.log.error(
u'Parameter id_filter is invalid. Value: %s.', kwargs['id_filter'])
raise InvalidValueError(None, 'id_filter', kwargs['id_filter'])
else:
# Check existence
fil = Filter().get_by_pk(kwargs['id_filter'])
try:
# Remove filter and its relationships
fil.delete()
except Exception, e:
self.log.error(u'Failed to remove the filter.')
raise e
return self.response(dumps_networkapi({}))
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to get User by the identifier.
URL: user/get/<id_user>/
"""
try:
self.log.info("Get User by the identifier")
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_user = kwargs.get('id_user')
# Valid User ID
if not is_valid_int_greater_zero_param(id_user):
self.log.error(
u'The id_user parameter is not a valid value: %s.', id_user)
raise InvalidValueError(None, 'id_user', id_user)
# Find User by ID to check if it exist
usr = Usuario.get_by_pk(id_user)
user_map = dict()
user_map['usuario'] = model_to_dict(usr)
user_map['usuario']['grupos'] = user_map['usuario']['grupos'] if user_map['usuario'][
'grupos'] is not None and len(user_map['usuario']['grupos']) > 0 else [None]
return self.response(dumps_networkapi(user_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to get Group User.
URL: ugroup/get/<id_ugroup>/
"""
try:
self.log.info("Get Group User by ID")
id_ugroup = kwargs.get('id_ugroup')
# User permission
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Group User ID
if not is_valid_int_greater_zero_param(id_ugroup):
self.log.error(
u'The id_ugroup parameter is not a valid value: %s.', id_ugroup)
raise InvalidValueError(None, 'id_ugroup', id_ugroup)
# Find Group User by ID to check if it exist
ugroup = UGrupo.get_by_pk(id_ugroup)
ugroup_map = dict()
ugroup_map['user_group'] = model_to_dict(ugroup)
return self.response(dumps_networkapi(ugroup_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat GET requests to get a Filter by id.
URL: filter/get/<id_filter>/
"""
try:
self.log.info("Get Filter by id")
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(u"User does not have permission to perform the operation.")
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs["id_filter"]):
self.log.error(u"Parameter id_filter is invalid. Value: %s.", kwargs["id_filter"])
raise InvalidValueError(None, "id_filter", kwargs["id_filter"])
else:
# Check existence
fil = Filter().get_by_pk(kwargs["id_filter"])
filter_dict = model_to_dict(fil)
filter_dict["equip_types"] = list()
for fil_equip_type in fil.filterequiptype_set.all():
filter_dict["equip_types"].append(model_to_dict(fil_equip_type.equiptype))
return self.response(dumps_networkapi({"filter": filter_dict}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições GET para consulta de HealthCheckExpects por id.
Lista as informações de um HealthCheckExpect por id.
URL: /healthcheckexpect/get/<id_healthcheck_expect>/
"""
try:
if not has_perm(user,
AdminPermission.HEALTH_CHECK_EXPECT,
AdminPermission.READ_OPERATION):
return self.not_authorized()
id_healthcheck = kwargs.get('id_healthcheck')
if not is_valid_int_greater_zero_param(id_healthcheck):
self.log.error(
u'The id_healthcheck parameter is not a valid value: %s.', id_healthcheck)
raise InvalidValueError(None, 'id_healthcheck', id_healthcheck)
heal = HealthcheckExpect.get_by_pk(id_healthcheck)
healthcheckexpect_map = model_to_dict(heal)
return self.response(dumps_networkapi({'healthcheck_expect': healthcheckexpect_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat requests DELETE to remove Equipment Script.
URL: equipmentscript/<id_equipment>/<id_script>/
"""
try:
self.log.info("Remove Equipment Script")
id_equipment = kwargs.get('id_equipment')
id_script = kwargs.get('id_script')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_equipment):
self.log.error(
u'The id_equipment parameter is not a valid value: %s.',
id_equipment)
raise InvalidValueError(None, 'id_equipment', id_equipment)
# Valid ID Script
if not is_valid_int_greater_zero_param(id_script):
self.log.error(
u'The id_script parameter is not a valid value: %s.',
id_script)
raise InvalidValueError(None, 'id_script', id_script)
# Find Equipment by ID to check if it exist
Equipamento.get_by_pk(id_equipment)
# Find Script by ID to check if it exist
Roteiro.get_by_pk(id_script)
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION, None,
id_equipment,
AdminPermission.EQUIP_WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
with distributedlock(LOCK_EQUIPMENT_SCRIPT % id_script):
EquipamentoRoteiro.remove(user, id_equipment, id_script)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Treat PUT requests to dissociate Filter and TipoEquipamento.
URL: filter/<id_filter>/dissociate/<id_equip_type>
"""
try:
self.log.info("")
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
if not is_valid_int_greater_zero_param(kwargs['id_filter']):
self.log.error(
u'Parameter id_filter is invalid. Value: %s.', kwargs['id_filter'])
raise InvalidValueError(None, 'id_filter', kwargs['id_filter'])
else:
# Check existence
fil = Filter().get_by_pk(kwargs['id_filter'])
if not is_valid_int_greater_zero_param(kwargs['id_equip_type']):
self.log.error(
u'Parameter id_equip_type is invalid. Value: %s.', kwargs['id_equip_type'])
raise InvalidValueError(
None, 'id_equip_type', kwargs['id_equip_type'])
else:
# Check existence
eq_tp = TipoEquipamento().get_by_pk(kwargs['id_equip_type'])
# Delete association
try:
association = FilterEquipType.objects.get(
filter=fil.id, equiptype=eq_tp.id)
## Only delete if there's no conflicts ##
association.delete(user)
except ObjectDoesNotExist, e:
# Association doesn't exist, ok
self.log.error(e)
pass
return self.response(dumps_networkapi({}))
def handle_post(self, request, user, *args, **kwargs):
"""Handles POST requests to save a new Rule
URL: rule/save/
"""
try:
self.log.info('Save rule to an environment')
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# 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.')
rule_map = networkapi_map.get('map')
if rule_map is None:
return self.response_error(3, u'There is no value to the environment_vip tag of XML request.')
# Get XML data
id_env = rule_map['id_env']
name = rule_map['name']
contents = rule_map['contents'] if type(
rule_map['contents']) is list else [rule_map['contents'], ]
blocks_id = rule_map['blocks_id'] if type(
rule_map['blocks_id']) is list else [rule_map['blocks_id'], ]
if not is_valid_int_greater_zero_param(id_env):
self.log.error(
u'The id_env parameter is not a valid value: %s.', id_env)
raise InvalidValueError(None, 'id_env', id_env)
if not name or len(name) > 80:
self.log.error(
u'The name parameter is not a valid value: %s.', name)
raise InvalidValueError(None, 'name', name)
environment = Ambiente.get_by_pk(id_env)
new_rule = Rule()
new_rule.name = name
new_rule.environment = environment
new_rule.save()
self.__save_rule_contents(
contents, blocks_id, environment, new_rule, user)
return self.response(dumps_networkapi({}))
except AmbienteNotFoundError, e:
self.log.error('Environment not found')
return self.response_error(112)
def handle_post(self, request, user, *args, **kwargs):
"""Handles POST requests to save a new Rule
URL: rule/save/
"""
try:
self.log.info("Save rule to an environment")
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# 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.')
rule_map = networkapi_map.get('map')
if rule_map is None:
return self.response_error(3, u'There is no value to the environment_vip tag of XML request.')
# Get XML data
id_env = rule_map['id_env']
name = rule_map['name']
contents = rule_map['contents'] if type(
rule_map['contents']) is list else [rule_map['contents'], ]
blocks_id = rule_map['blocks_id'] if type(
rule_map['blocks_id']) is list else [rule_map['blocks_id'], ]
if not is_valid_int_greater_zero_param(id_env):
self.log.error(
u'The id_env parameter is not a valid value: %s.', id_env)
raise InvalidValueError(None, 'id_env', id_env)
if not name or len(name) > 80:
self.log.error(
u'The name parameter is not a valid value: %s.', name)
raise InvalidValueError(None, 'name', name)
environment = Ambiente.get_by_pk(id_env)
new_rule = Rule()
new_rule.name = name
new_rule.environment = environment
new_rule.save()
self.__save_rule_contents(
contents, blocks_id, environment, new_rule, user)
return self.response(dumps_networkapi({}))
except AmbienteNotFoundError, e:
self.log.error('Environment not found')
return self.response_error(112)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the VIPs related to Environment VIP.
URL: environmentvip/<id_environment_vip>/vip/all'
"""
try:
self.log.info(
'GET to list all the VIPs related to Environment VIP')
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_VIP,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Get data
id_environment_vip = kwargs.get('id_environment_vip')
# Valid Environment VIP ID
if not is_valid_int_greater_zero_param(id_environment_vip):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.',
id_environment_vip)
raise InvalidValueError(None, 'id_environment_vip',
id_environment_vip)
# Find Environment VIP by ID to check if it exist
environment_vip = EnvironmentVip.get_by_pk(id_environment_vip)
# Find Request VIP - IPv4 by ID Environment
vips_ipv4 = RequisicaoVips.objects.filter(
ip__networkipv4__ambient_vip__id=environment_vip.id)
# Find Request VIP - IPv6 by ID Environment
vips_ipv6 = RequisicaoVips.objects.filter(
ipv6__networkipv6__ambient_vip__id=environment_vip.id)
vips = {}
for vips_ip in [vips_ipv4, vips_ipv6]:
for vip in vips_ip:
v = {}
v = vip.variables_to_map()
v['id'] = vip.id
v['validado'] = vip.validado
v['vip_criado'] = vip.vip_criado
v['id_ip'] = vip.ip_id
v['id_ipv6'] = vip.ipv6_id
v['id_healthcheck_expect'] = vip.healthcheck_expect_id
vips['vip_%s' % (vip.id)] = v
return self.response(dumps_networkapi(vips))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Treat PUT requests to edit Access Type.
URL: /tipoacesso/<id_tipo_acesso>/
"""
try:
if not has_perm(user, AdminPermission.ACCESS_TYPE_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(u"User does not have permission to perform the operation.")
raise UserNotAuthorizedError(None)
# Valid Access Type ID
tipo_acesso_id = kwargs.get("id_tipo_acesso")
if not is_valid_int_greater_zero_param(tipo_acesso_id):
self.log.error(u"The tipo_acesso_id parameter is not a valid value: %s.", tipo_acesso_id)
raise InvalidValueError(None, "tipo_acesso_id", tipo_acesso_id)
xml_map, attrs_map = loads(request.raw_post_data)
networkapi_map = xml_map.get("networkapi")
if networkapi_map is None:
return self.response_error(3, u"There is no networkapi tag in request XML.")
tipo_acesso_map = networkapi_map.get("tipo_acesso")
if tipo_acesso_map is None:
return self.response_error(3, u"There is no tipo_acesso tag in request XML.")
# Valid protocol
protocol = tipo_acesso_map.get("protocolo")
if (
not is_valid_string_minsize(protocol, 3)
or not is_valid_string_maxsize(protocol, 45)
or not is_valid_regex(protocol, r"^[- a-zA-Z0-9]+$")
):
self.log.error(u"Parameter protocol is invalid. Value: %s", protocol)
raise InvalidValueError(None, "protocol", protocol)
# Verify existence
tpa = TipoAcesso.get_by_pk(tipo_acesso_id)
tpa.protocolo = protocol
try:
if len(TipoAcesso.objects.filter(protocolo__iexact=protocol).exclude(id=tpa.id)) > 0:
raise DuplicateProtocolError(None, u"Access Type with protocol %s already exists" % protocol)
except TipoAcesso.DoesNotExist:
pass
with distributedlock(LOCK_TYPE_ACCESS % tipo_acesso_id):
try:
# save access type
tpa.save(user)
except Exception, e:
self.log.error(u"Failed to update TipoAcesso.")
raise TipoAcessoError(e, u"Failed to update TipoAcesso.")
return self.response(dumps_networkapi({}))
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para listar uma requisição de VIP.
Filtra a requisição de VIP por chave primária.
URL: vip/id_vip
"""
try:
if kwargs.get('id_vip') is None:
return super(RequisicaoVipsResource,
self).handle_get(request, user, *args, **kwargs)
if not has_perm(user, AdminPermission.VIPS_REQUEST,
AdminPermission.READ_OPERATION):
return self.not_authorized()
# Valid Ip ID
if not is_valid_int_greater_zero_param(kwargs.get('id_vip')):
self.log.error(
u'The id_vip parameter is not a valid value: %s.',
kwargs.get('id_vip'))
raise InvalidValueError(None, 'id_vip', kwargs.get('id_vip'))
request_vip = RequisicaoVips.get_by_pk(kwargs.get('id_vip'))
request_vip_map = request_vip.variables_to_map()
""""""
vip_port_list, reals_list, reals_priority, reals_weight = request_vip.get_vips_and_reals(
request_vip.id)
if reals_list:
request_vip_map['reals'] = {'real': reals_list}
request_vip_map['reals_prioritys'] = {
'reals_priority': reals_priority
}
request_vip_map['reals_weights'] = {
'reals_weight': reals_weight
}
request_vip_map['portas_servicos'] = {'porta': vip_port_list}
""""""
request_vip_map['id'] = request_vip.id
request_vip_map['validado'] = convert_boolean_to_int(
request_vip.validado)
request_vip_map['vip_criado'] = convert_boolean_to_int(
request_vip.vip_criado)
request_vip_map['id_ip'] = request_vip.ip_id
request_vip_map['id_ipv6'] = request_vip.ipv6_id
request_vip_map[
'id_healthcheck_expect'] = request_vip.healthcheck_expect_id
request_vip_map['l7_filter'] = request_vip.l7_filter
request_vip_map['rule_id'] = request_vip.rule_id
return self.response(dumps_networkapi({'vip': request_vip_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def save_or_update(self, request, user, update=False):
try:
# User permission
if not has_perm(user, AdminPermission.VIP_VALIDATION,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# 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.')
map = networkapi_map.get('map')
if map is None:
return self.response_error(
3, u'There is no value to the map tag of XML request.')
environment_id = map['id_env']
if not is_valid_int_greater_zero_param(environment_id):
self.log.error(
u'The environment_id parameter is not a valid value: %s.',
environment_id)
raise InvalidValueError(None, 'environment_id', environment_id)
environment = Ambiente.get_by_pk(environment_id)
if update:
for block in environment.blockrules_set.all():
block.delete()
else:
if environment.blockrules_set.count() > 0:
return self.response_error(357)
if 'blocks' in map:
blocks = map['blocks'] if type(map['blocks']) is list else [
map['blocks'],
]
for order, content in enumerate(blocks):
block = BlockRules()
block.content = content
block.order = order
block.environment = environment
block.save()
return self.response(dumps_networkapi({}))
except AmbienteNotFoundError, e:
self.log.error('Environment not found')
return self.response_error(112)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat requests DELETE to remove Equipment Script.
URL: equipmentscript/<id_equipment>/<id_script>/
"""
try:
self.log.info("Remove Equipment Script")
id_equipment = kwargs.get("id_equipment")
id_script = kwargs.get("id_script")
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_equipment):
self.log.error(u"The id_equipment parameter is not a valid value: %s.", id_equipment)
raise InvalidValueError(None, "id_equipment", id_equipment)
# Valid ID Script
if not is_valid_int_greater_zero_param(id_script):
self.log.error(u"The id_script parameter is not a valid value: %s.", id_script)
raise InvalidValueError(None, "id_script", id_script)
# Find Equipment by ID to check if it exist
Equipamento.get_by_pk(id_equipment)
# Find Script by ID to check if it exist
Roteiro.get_by_pk(id_script)
# User permission
if not has_perm(
user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
id_equipment,
AdminPermission.EQUIP_WRITE_OPERATION,
):
self.log.error(u"User does not have permission to perform the operation.")
raise UserNotAuthorizedError(None)
with distributedlock(LOCK_EQUIPMENT_SCRIPT % id_script):
EquipamentoRoteiro.remove(user, id_equipment, id_script)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def _validate_environment_id(self, id_environment):
if not is_valid_int_greater_zero_param(id_environment):
self.log.error(
u'The id_environment parameter is invalid value: %s.', id_environment)
raise InvalidValueError(None, 'id_environment', id_environment)
Ambiente().get_by_pk(id_environment)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat requests PUT to delete Environment VIP.
URL: environmentvip/<id_environment_vip>/
"""
try:
self.log.info('Delete Environment VIP')
id_environment_vip = kwargs.get('id_environment_vip')
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_VIP,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Environment VIP ID
if not is_valid_int_greater_zero_param(id_environment_vip):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.',
id_environment_vip)
raise InvalidValueError(None, 'id_environment_vip',
id_environment_vip)
# Find Environment VIP by ID to check if it exist
environment_vip = EnvironmentVip.get_by_pk(id_environment_vip)
with distributedlock(LOCK_ENVIRONMENT_VIP % id_environment_vip):
# Find networkIPv4 by Environment VIP to check if is greater
# than zero
if len(
NetworkIPv4.objects.filter(
ambient_vip=environment_vip.id)) > 0:
return self.response_error(284)
# Find networkIPv6 by Environment VIP to check if is greater
# than zero
if len(
NetworkIPv6.objects.filter(
ambient_vip=environment_vip.id)) > 0:
return self.response_error(285)
try:
# Delete Environment Vip
environment_vip.delete()
except Exception, e:
self.log.error(u'Failed to delete the environment vip.')
raise EnvironmentVipError(
e, u'Failed to delete the environment vip')
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para alterar a senha de um Usuario.
URL: user-change-pass/
"""
try:
xml_map, attrs_map = loads(request.raw_post_data)
self.log.info('Change user password')
# User permission
if not has_perm(user, AdminPermission.AUTHENTICATE, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(3, u'Não existe valor para a tag networkapi do XML de requisição.')
user_map = networkapi_map.get('user')
if user_map is None:
return self.response_error(3, u'Não existe valor para a tag usuario do XML de requisição.')
# Get XML data
id_user = user_map.get('user_id')
password = user_map.get('password')
# Valid ID User
if not is_valid_int_greater_zero_param(id_user):
self.log.error(
u'The id_user parameter is not a valid value: %s.', id_user)
raise InvalidValueError(None, 'id_user', id_user)
# Valid pwd
if not is_valid_string_minsize(password, 3) or not is_valid_string_maxsize(password, 45):
self.log.error(u'Parameter password is invalid. Value: ****')
raise InvalidValueError(None, 'password', '****')
# Find User by ID to check if it exist
usr = Usuario.get_by_pk(id_user)
with distributedlock(LOCK_USER % id_user):
# set variable
usr.pwd = hashlib.md5(password).hexdigest()
try:
# update User
usr.save(user)
except Exception, e:
self.log.error(u'Failed to update the user.')
raise UsuarioError(e, u'Failed to update the user.')
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para listar uma requisição de VIP.
Filtra a requisição de VIP por chave primária.
URL: vip/id_vip
"""
try:
if kwargs.get('id_vip') is None:
return super(RequisicaoVipsResource, self).handle_get(request, user, *args, **kwargs)
if not has_perm(user,
AdminPermission.VIPS_REQUEST,
AdminPermission.READ_OPERATION):
return self.not_authorized()
# Valid Ip ID
if not is_valid_int_greater_zero_param(kwargs.get('id_vip')):
self.log.error(
u'The id_vip parameter is not a valid value: %s.', kwargs.get('id_vip'))
raise InvalidValueError(None, 'id_vip', kwargs.get('id_vip'))
request_vip = RequisicaoVips.get_by_pk(kwargs.get('id_vip'))
request_vip_map = request_vip.variables_to_map()
""""""
vip_port_list, reals_list, reals_priority, reals_weight = request_vip.get_vips_and_reals(
request_vip.id)
if reals_list:
request_vip_map['reals'] = {'real': reals_list}
request_vip_map['reals_prioritys'] = {
'reals_priority': reals_priority}
request_vip_map['reals_weights'] = {
'reals_weight': reals_weight}
request_vip_map['portas_servicos'] = {'porta': vip_port_list}
""""""
request_vip_map['id'] = request_vip.id
request_vip_map['validado'] = convert_boolean_to_int(
request_vip.validado)
request_vip_map['vip_criado'] = convert_boolean_to_int(
request_vip.vip_criado)
request_vip_map['id_ip'] = request_vip.ip_id
request_vip_map['id_ipv6'] = request_vip.ipv6_id
request_vip_map[
'id_healthcheck_expect'] = request_vip.healthcheck_expect_id
request_vip_map['l7_filter'] = request_vip.l7_filter
request_vip_map['rule_id'] = request_vip.rule_id
return self.response(dumps_networkapi({'vip': request_vip_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all Environments.
URL: /ambiente/equip/id_equip
"""
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
id_equip = kwargs.get('id_equip')
if not is_valid_int_greater_zero_param(id_equip):
raise InvalidValueError(None, 'id_equip', id_equip)
# Business Rules
equip = Equipamento.get_by_pk(id_equip)
environments_list = EquipamentoAmbiente.get_by_equipment(equip.id)
# Get all environments in DB
lists_aux = []
for environment in environments_list:
env = Ambiente.get_by_pk(environment.ambiente.id)
env_map = model_to_dict(env)
env_map['grupo_l3_name'] = env.grupo_l3.nome
env_map['ambiente_logico_name'] = env.ambiente_logico.nome
env_map['divisao_dc_name'] = env.divisao_dc.nome
env_map['is_router'] = environment.is_router
try:
env_map['range'] = str(
env.min_num_vlan_1) + ' - ' + str(env.max_num_vlan_1)
if env.min_num_vlan_1 != env.min_num_vlan_2:
env_map['range'] = env_map[
'range'] + '; ' + str(env.min_num_vlan_2) + ' - ' + str(env.max_num_vlan_2)
except:
env_map['range'] = 'Nao definido'
if env.filter is not None:
env_map['filter_name'] = env.filter.name
lists_aux.append(env_map)
# Return XML
environment_list = dict()
environment_list['ambiente'] = lists_aux
return self.response(dumps_networkapi(environment_list))
except InvalidValueError, e:
self.log.error(
u'Parameter %s is invalid. Value: %s.', e.param, e.value)
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Environment by Environment Vip.
URL: environment/environmentvip/<environment_vip_id>'
"""
try:
self.log.info(
"GET to list all the Environment by Environment Vip.")
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
environment_vip_id = kwargs.get('environment_vip_id')
# Valid Environment VIP ID
if not is_valid_int_greater_zero_param(environment_vip_id):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.',
environment_vip_id)
raise InvalidValueError(None, 'environment_vip_id',
environment_vip_id)
# Find Environment VIP by ID to check if it exist
environment_vip = EnvironmentVip.get_by_pk(environment_vip_id)
environment_related_list = []
for env_env_vip in environment_vip.environmentenvironmentvip_set.all(
):
environment_map = {}
environment_map['environment_id'] = env_env_vip.environment.id
environment_map[
'environment_vip_id'] = env_env_vip.environment_vip.id
environment_map[
'environment'] = env_env_vip.environment.grupo_l3.nome
environment_map[
'ambiente_logico_name'] = env_env_vip.environment.ambiente_logico.nome
environment_map[
'divisao_dc_name'] = env_env_vip.environment.divisao_dc.nome
environment_related_list.append(environment_map)
return self.response(
dumps_networkapi(
{'environment_related_list': environment_related_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Treat requests PUT to change Environment VIP.
URL: environmentvip/<id_environment_vip>/
"""
try:
self.log.info("Change Environment VIP")
id_environment_vip = kwargs.get('id_environment_vip')
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_VIP, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# 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.')
environmentvip_map = networkapi_map.get('environment_vip')
if environmentvip_map is None:
return self.response_error(3, u'There is no value to the environment_vip tag of XML request.')
# Valid Environment VIP ID
if not is_valid_int_greater_zero_param(id_environment_vip):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.', id_environment_vip)
raise InvalidValueError(
None, 'id_environment_vip', id_environment_vip)
# Find Environment VIP by ID to check if it exist
environment_vip = EnvironmentVip.get_by_pk(id_environment_vip)
with distributedlock(LOCK_ENVIRONMENT_VIP % id_environment_vip):
# Valid Environment Vip
environment_vip.valid_environment_vip(environmentvip_map)
try:
# Update Environment Vip
environment_vip.save()
except Exception, e:
self.log.error(u'Failed to update the environment vip.')
raise EnvironmentVipError(
e, u'Failed to update the environment vip')
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def _validate_environment_id(self, id_environment):
if not is_valid_int_greater_zero_param(id_environment):
self.log.error(
u'The id_environment parameter is invalid value: %s.',
id_environment)
raise InvalidValueError(None, 'id_environment', id_environment)
""" Check if exists"""
Ambiente().get_by_pk(id_environment)
def create(self, authenticated_user):
"""Add new port channel"""
# Checks if name is valid
try:
if not is_valid_int_greater_zero_param(self.nome):
raise InvalidValueError(None, 'nome', self.nome)
except Exception, e:
raise InvalidValueError(None, e.param, e.value)
def _validate_configuration_id(self, id_configuration):
if not is_valid_int_greater_zero_param(id_configuration):
self.log.error(
u'The id_configuration parameter is invalid value: %s.',
id_configuration)
raise InvalidValueError(None, 'id_configuration', id_configuration)
""" Check if exists"""
IPConfig().get_by_pk(id_configuration)
def create(self, authenticated_user):
"""Add new port channel"""
# Checks if name is valid
try:
if not is_valid_int_greater_zero_param(self.nome):
raise InvalidValueError(None, 'nome', self.nome)
except Exception, e:
raise InvalidValueError(None, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all traffic return of the Option VIP by Environment Vip.
URL: environment-vip/get/trafficreturn/<id_evip>
"""
try:
self.log.info(
"GET to list all the Option VIP by Environment Vip - traffic return."
)
# 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)
id_environment_vip = kwargs.get('id_evip')
# Valid Environment VIP ID
if not is_valid_int_greater_zero_param(id_environment_vip):
self.log.error(
u'The id_environment_vip parameter is not a valid value: %s.',
id_environment_vip)
raise InvalidValueError(None, 'id_environment_vip',
id_environment_vip)
# Find Environment VIP by ID to check if it exist
environment_vip = EnvironmentVip.get_by_pk(id_environment_vip)
#self.log.info(str(environment_vip))
ovips = OptionVip.get_all_trafficreturn(environment_vip.id)
#self.log.info(str(ovips))
ovip_dict = dict()
ovip_list = []
for ovip in ovips:
ovip_dict['trafficreturn_opt'] = ovip.nome_opcao_txt
ovip_list.append(ovip_dict)
ovip_dict = dict()
self.log.info(str(ovip_list))
return self.response(
dumps_networkapi({'trafficreturn_opt': ovip_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to verify that the IP belongs to environment.
URLs: /ip/x1.x2.x3.x4/ambiente/<id_amb>
URLs: /ip/<ip>/ambiente/<id_amb>
"""
self.log.info("GET to verify that the IP belongs to environment")
try:
# User permission
if not has_perm(user, AdminPermission.IPS,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
environment_id = kwargs.get('id_amb')
# Valid Environment ID
if not is_valid_int_greater_zero_param(environment_id):
self.log.error(
u'The id_environment parameter is not a valid value: %s.',
environment_id)
raise InvalidValueError(None, 'id_environment', environment_id)
ip = kwargs.get('ip')
# Valid IP
if not is_valid_ipv4(ip):
self.log.error(u'Parameter ip is invalid. Value: %s.', ip)
raise InvalidValueError(None, 'ip', ip)
# Find Environment by ID to check if it exist
Ambiente.get_by_pk(environment_id)
# Existing IP
octs = str(IPAddress(ip, 4).exploded).split('.')
ip = Ip.get_by_octs_and_environment(octs[0], octs[1], octs[2],
octs[3], environment_id)
# Build dictionary return
ip_map = dict()
ip_map['id'] = ip.id
ip_map['id_vlan'] = ip.networkipv4.vlan.id
ip_map['oct4'] = ip.oct4
ip_map['oct3'] = ip.oct3
ip_map['oct2'] = ip.oct2
ip_map['oct1'] = ip.oct1
ip_map['descricao'] = ip.descricao
return self.response(dumps_networkapi({'ip': ip_map}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def update(self, data):
try:
id_channel = data.get('id_channel')
nome = data.get('nome')
if not is_valid_int_greater_zero_param(nome):
raise InvalidValueError(None, 'Channel number',
'must be integer.')
lacp = data.get('lacp')
int_type = data.get('int_type')
vlan_nativa = data.get('vlan')
envs_vlans = data.get('envs')
ids_interface = data.get('ids_interface')
if ids_interface is None:
raise InterfaceError('No interfaces selected')
if type(ids_interface) == list:
interfaces_list = ids_interface
else:
interfaces_list = str(ids_interface).split('-')
api_interface_facade.verificar_vlan_nativa(vlan_nativa)
# verifica se o nome do port channel já existe no equipamento
self.channel = PortChannel.get_by_pk(int(id_channel))
if not nome == self.channel.nome:
api_interface_facade.verificar_nome_channel(
nome, interfaces_list)
# buscar interfaces do channel
interfaces = Interface.objects.all().filter(channel__id=id_channel)
ids_list = []
for i in interfaces:
ids_list.append(i.id)
self._dissociate_interfaces_from_channel(ids_list, ids_interface)
# update channel
self.channel.nome = str(nome)
self.channel.lacp = convert_string_or_int_to_boolean(lacp)
self.channel.save()
int_type = TipoInterface.get_by_name(str(int_type))
self._update_interfaces_from_http_put(ids_interface, int_type,
vlan_nativa, envs_vlans)
except Exception as err:
return {"error": str(err)}
return {"port_channel": self.channel}
def handle_put(self, request, user, *args, **kwargs):
'''
Treat requests PUT to add a network IPv4 with num hosts param
URL: network/ipv4/add/
'''
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VLAN_MANAGEMENT,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Business Validations
# Load XML data
xml_map, _ = loads(request.raw_post_data)
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
msg = u'There is no value to the networkapi tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
vlan_map = networkapi_map.get('vlan')
if vlan_map is None:
msg = u'There is no value to the vlan tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
# Get XML data
vlan_id = vlan_map.get('id_vlan')
network_type = vlan_map.get('id_tipo_rede')
environment_vip = vlan_map.get('id_ambiente_vip')
num_hosts = vlan_map.get('num_hosts')
# Valid num_hosts
if not is_valid_int_greater_zero_param(
num_hosts) or int(num_hosts) > MAX_IPV4_HOSTS:
self.log.error(u'Parameter num_hosts is invalid. Value: %s.',
num_hosts)
return self.response_error(269, 'num_hosts', num_hosts)
num_hosts = int(num_hosts)
# Get configuration
conf = Configuration.get()
num_hosts += conf.IPv4_MIN + conf.IPv4_MAX
prefix = get_prefix_IPV4(num_hosts)
self.log.info(u'Prefix for %s hosts: %s' % (num_hosts, prefix))
return self.network_ipv4_add(user, vlan_id, network_type,
environment_vip, prefix)
def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para alterar um grupo de equipamento.
URL: egrupo/<id_grupo>/
"""
try:
egroup_id = kwargs.get('id_grupo')
if not is_valid_int_greater_zero_param(egroup_id):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.',
egroup_id)
raise InvalidValueError(None, 'egroup_id', egroup_id)
egrp = EGrupo.get_by_pk(egroup_id)
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
xml_map, attrs_map = loads(request.raw_post_data)
self.log.debug('XML_MAP: %s', xml_map)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'Não existe valor para a tag networkapi do XML de requisição.'
)
egroup_map = networkapi_map.get('grupo')
if egroup_map is None:
return self.response_error(
3,
u'Não existe valor para a tag grupo do XML de requisição.')
name = egroup_map.get('nome')
if not is_valid_string_maxsize(name, 100):
self.log.error(u'Parameter name is invalid. Value: %s', name)
raise InvalidValueError(None, 'name', name)
with distributedlock(LOCK_GROUP_EQUIPMENT % egroup_id):
# Destroy equipment's cache
equip_id_list = []
for equipament in egrp.equipamento_set.all():
equip_id_list.append(equipament.id)
destroy_cache_function(equip_id_list, True)
EGrupo.update(user, egroup_id, nome=name)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para alterar direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/<id_direito>/
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
right_id = kwargs.get('id_direito')
if not is_valid_int_greater_zero_param(right_id):
self.log.error(
u'The right_id parameter is not a valid value: %s.',
right_id)
raise InvalidValueError(None, 'right_id', right_id)
try:
xml_map, attrs_map = loads(request.raw_post_data)
self.log.debug('XML_MAP: %s', xml_map)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisicao.')
return self.response_error(3, x)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'Não existe valor para a tag networkapi do XML de requisição.'
)
direito_map = networkapi_map.get('direito_grupo_equipamento')
if direito_map is None:
return self.response_error(
3,
u'Não existe valor para a tag direito_grupo_equipamento do XML de requisição.'
)
response = self.__valida_request(direito_map, False)
if response is not None:
return response
with distributedlock(LOCK_GROUP_RIGHTS % right_id):
DireitosGrupoEquipamento.update(
user,
right_id,
leitura=direito_map.get('leitura'),
escrita=direito_map.get('escrita'),
alterar_config=direito_map.get('alterar_config'),
exclusao=direito_map.get('exclusao'))
return self.response(dumps_networkapi({}))
