def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições GET para consulta de Informações de Acesso a Equipamentos.
Permite a consulta de Informações de Acesso a Equipamentos existentes.
URL: /equipamentoacesso/
"""
try:
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
# Efetua a consulta de todos os tipos de acesso
results = EquipamentoAcesso.search(user.grupos.all())
if results.count() > 0:
# Monta lista com dados retornados
map_list = []
for item in results:
item_map = self.get_equipamento_acesso_map(item)
if item_map not in map_list:
map_list.append(item_map)
# Gera response (XML) com resultados
return self.response(dumps_networkapi({'equipamento_acesso': map_list}))
else:
# Gera response (XML) para resultado vazio
return self.response(dumps_networkapi({}))
except (EquipamentoError, GrupoError):
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Model.
URL: model/all
"""
try:
self.log.info("GET to list all the Model")
script_id = kwargs.get('script_id')
# User permission
if not has_perm(user, AdminPermission.BRAND_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
model_list = []
if script_id is not None:
models = ModeloRoteiro.objects.filter(roteiro__id=int(script_id))
for i in models:
model_list.append(self.model_map(i.modelo))
return self.response(dumps_networkapi({'model': model_list}))
for model in Modelo.objects.all():
model_list.append(self.model_map(model))
return self.response(dumps_networkapi({'model': model_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except EquipamentoError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições GET para consulta de tipos de rede.
Permite a consulta de tipos de rede existentes.
URL: /tiporede/
"""
try:
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
# Efetua a consulta de todos os tipos de rede
results = TipoRede.search()
if results.count() > 0:
# Monta lista com dados retornados
map_list = []
for item in results:
item_map = self.get_tipo_rede_map(item)
map_list.append(item_map)
# Gera response (XML) com resultados
return self.response(dumps_networkapi({'tipo_rede': map_list}))
else:
# Gera response (XML) para resultado vazio
return self.response(dumps_networkapi({}))
except (VlanError, GrupoError):
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Script.
URL: script/all
"""
try:
self.log.info("GET to list all the Script")
# User permission
if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
id_script = kwargs.get('id_script')
if id_script is not None:
script = Roteiro.get_by_pk(int(id_script))
script = model_to_dict(script)
return self.response(dumps_networkapi({'script': script}))
script_list = []
for script in Roteiro.objects.all():
script_list.append(model_to_dict(script))
return self.response(dumps_networkapi({'script': script_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except RoteiroError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Treat GET requests to get all network types.
URL: /net_type/
"""
try:
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
results = TipoRede.objects.all()
if results.count() > 0:
map_list = []
for item in results:
item_map = self.get_net_type_map(item)
map_list.append(item_map)
# Build response (XML)
return self.response(dumps_networkapi({'net_type': map_list}))
else:
# Build response (XML) to empty return
return self.response(dumps_networkapi({}))
except (VlanError, GrupoError):
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find all Racks
URLs: /rack/find/
"""
self.log.info('List all Racks')
try:
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
self.log.error( u'User does not have permission to perform the operation.')
return self.not_authorized()
rack_list = []
for rack in Rack.objects.all():
rack_list.append(model_to_dict(rack))
return self.response(dumps_networkapi({'rack': rack_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except RackError:
return self.response_error(379)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Option VIP.
URL: vip/dsrl3//all'
"""
try:
self.log.info("GET to list all the DSRL3 of VIPs")
# User permission
if not has_perm(user, AdminPermission.OPTION_VIP, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Find All Option VIP
dsrl3 = DsrL3_to_Vip.get_all()
ovips = []
for ov in dsrl3:
ovips.append(model_to_dict(ov))
return self.response(dumps_networkapi({'dsrl3': ovips}))
except UserNotAuthorizedError:
return self.not_authorized()
except OptionVipError:
return self.response_error(1)
def handle_post(self, request, user, *args, **kwargs):
"""Treat requests POST to create the configuration file.
URL: rack/gerar-arq-config/id_rack
"""
try:
self.log.info("CONFIG")
# User permission
if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
rack_id = kwargs.get('id_rack')
rack = Rack()
rack = rack.get_by_pk(rack_id)
var = False
#Chama o script para gerar os arquivos de configuracao
var = gera_config(rack)
rack.__dict__.update(id=rack_id, config=var)
rack.save()
success_map = dict()
success_map['rack_conf'] = var
map = dict()
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
except RackConfigError, e:
return self.response_error(382, e.param, e.value)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Permissions.
URL: perms/all
"""
try:
self.log.info("GET to list all the Permissions")
# 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)
perms_list = []
for perm in Permission.objects.all():
perms_list.append(model_to_dict(perm))
return self.response(dumps_networkapi({'perms': perms_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except GrupoError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find all finalitys of environment VIP.
URLs: /vip/get/finality
"""
self.log.info("Find all finality distinct of environment_vip")
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VIPS_REQUEST, AdminPermission.READ_OPERATION):
self.log.error(u"User does not have permission to perform the operation.")
return self.not_authorized()
evip = EnvironmentVip()
# Business Validations
evips = evip.list_all_finalitys()
finality_map = dict()
finality_list = []
for evip in evips:
finality_map["finality"] = evip.get("finalidade_txt")
finality_list.append(finality_map)
finality_map = dict()
return self.response(dumps_networkapi({"finalidade": finality_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 Group l3.
URL: groupl3/all
"""
try:
self.log.info("GET to list all the Group l3")
# 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)
groupl3_list = []
for group in GrupoL3.objects.all():
groupl3_list.append(model_to_dict(group))
return self.response(dumps_networkapi({'group_l3': groupl3_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except AmbienteError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Treat GET requests list all Filters.
URL: filter/all/
"""
try:
self.log.info("List all Filters")
# 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()
# Business Rules
filters = Filter.objects.all()
filter_list = []
for filter_ in filters:
filter_dict = model_to_dict(filter_)
filter_dict['equip_types'] = list()
for fil_equip_type in filter_.filterequiptype_set.all():
filter_dict['equip_types'].append(
model_to_dict(fil_equip_type.equiptype))
filter_list.append(filter_dict)
return self.response(dumps_networkapi({'filter': filter_list}))
except BaseException, e:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all .
URL: interface/get-type/
"""
try:
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
lista_tipo_interface = []
tipos_interface = TipoInterface.objects.all()
for tipo in tipos_interface:
lista_tipo_interface.append(tipo)
lists = self.get_envs(lista_tipo_interface)
# Return XML
interface_list = dict()
interface_list['tipo_interface'] = lists
return self.response(dumps_networkapi(interface_list))
except GrupoError:
return self.response_error(1)
except InvalidValueError, e:
return self.response_error(369, 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_delete(self, request, user, *args, **kwargs):
"""Treat requests GET to Remove Prefix Configuration.
URL: /environment/configuration/remove/environment_id/configuration_id/
"""
try:
configuration_id = kwargs.get('configuration_id')
environment_id = kwargs.get('environment_id')
self._validate_permission(user)
self._validate_configuration_id(configuration_id)
self._validate_environment_id(environment_id)
ip_config = IPConfig.remove(
self, user, environment_id, configuration_id)
return self.response(dumps_networkapi({'ip_config': ip_config}))
except PermissionError:
return self.not_authorized()
except IPConfigNotFoundError, e:
self.log.error(u'IpCofig not registred')
return self.response_error(301)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to list all equipment.
URLs: equipament/list/
"""
try:
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
equip_list = Equipamento.objects.all()
map_dicts = []
for equip in equip_list:
map_dicts.append(model_to_dict(equip))
equip_map = dict()
equip_map['equipamentos'] = map_dicts
# Return XML
return self.response(dumps_networkapi(equip_map))
except (EquipamentoError, GrupoError):
return self.response_error(1)
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):
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 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 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 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):
"""Handles GET requests to find EnvironmentInterface.
URLs: int/get-env-by-interface/<id_interface>
"""
self.log.info('buscando os ambientes associados a uma interface')
try:
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Get XML data
interface = kwargs.get('id_interface')
int_ambiente = EnvironmentInterface.get_by_interface(int(interface))
ambiente_map = []
for ids in int_ambiente:
ambiente_map.append(self.get_environment_map(ids.ambiente))
return self.response(dumps_networkapi({'ambiente': ambiente_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 Equipment Type.
URL: equipmenttype/all
"""
try:
self.log.info("GET to list all Equipment Type")
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
map_list = []
for equipment_type in TipoEquipamento.objects.all():
eq_tp = {
'id': equipment_type.id, 'nome': equipment_type.tipo_equipamento}
map_list.append(eq_tp)
return self.response(dumps_networkapi({'equipment_type': map_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except EquipamentoError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find all Racks
URLs: /rack/find/
"""
self.log.info('Find all Racks')
try:
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
nome = kwargs.get('rack_name')
rack = Rack()
rack = rack.get_by_name(nome)
rack = model_to_dict(rack)
return self.response(dumps_networkapi({'rack': rack}))
except UserNotAuthorizedError:
return self.not_authorized()
except RackError:
return self.response_error(379)
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_get(self, request, user, *args, **kwargs):
"""Treat GET requests list all Environment VIP.
URL: environmentvip/all/
"""
try:
self.log.info('List all Environment VIP')
# Commons Validations
# 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.')
return self.not_authorized()
# Business Rules
evips = EnvironmentVip.objects.all()
evip_list = []
for evip in evips:
evip_list.append(model_to_dict(evip))
return self.response(dumps_networkapi({'environment_vip': evip_list}))
except (EnvironmentVipError, GrupoError), e:
self.log.error(e)
return self.response_error(1)
def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para inserir um grupo de equipamento.
URL: egrupo/
"""
try:
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)
egroup = EGrupo()
egroup.nome = name
egroup.create(user)
return self.response(dumps_networkapi({'grupo': {'id': egroup.id}}))
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):
"""Treat requests GET to list all the Script Type.
URL: scripttype/all
"""
try:
self.log.info('GET to list all the Script Type')
# User permission
if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
script_type_list = []
for script_type in TipoRoteiro.objects.all():
script_type_list.append(model_to_dict(script_type))
return self.response(dumps_networkapi({'script_type': script_type_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except RoteiroError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""
Handles GET requests to list all the VIPs.
URL: vip/all/
"""
try:
if not has_perm(user,
AdminPermission.VIPS_REQUEST,
AdminPermission.READ_OPERATION):
return self.not_authorized()
request_vips = RequisicaoVips.get_all()
vips = {}
for vip in request_vips:
request_vip_map = vip.variables_to_map()
request_vip_map['id'] = vip.id
request_vip_map['validado'] = vip.validado
request_vip_map['vip_criado'] = vip.vip_criado
request_vip_map['id_ip'] = vip.ip_id
request_vip_map['id_ipv6'] = vip.ipv6_id
request_vip_map[
'id_healthcheck_expect'] = vip.healthcheck_expect_id
vips['vip_%s' % (vip.id)] = request_vip_map
return self.response(dumps_networkapi(vips))
except (RequisicaoVipsNotFoundError):
return self.response_error(152)
except (RequisicaoVipsError, GrupoError):
return self.response_error(1)
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_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({}))
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to get API's version
URLs: /eventlog/version/
"""
try:
version = dict()
version['api_version'] = API_VERSION
return self.response(dumps_networkapi(version))
except BaseException, e:
return self.response_error(1)
def handle_post(self, request, user, *args, **kwargs):
"""Treat POST requests to add new network types.
URL: /net_type/
"""
try:
# Check permission
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Get request XML data
xml_map, attrs_map = loads(request.raw_post_data)
# Get networkapi tag map
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(3, u'There is no networkapi tag from request XML.')
# Get net_type tag map
net_type_map = networkapi_map.get('net_type')
if net_type_map is None:
return self.response_error(3, u'There is no tipo_rede tag from request XML.')
# Valid name attribute
name = net_type_map.get('name')
if not is_valid_string_minsize(name, 3) or not is_valid_string_maxsize(name, 100):
self.log.error(
u'Parameter %s is invalid. Value: %s.', 'name', name)
raise InvalidValueError(None, 'name', name)
net_type = TipoRede(tipo_rede=name)
try:
TipoRede.get_by_name(net_type.tipo_rede)
raise NetworkTypeNameDuplicatedError(
None, u'Network type with name %s already exist' % net_type.tipo_rede)
except NetworkTypeNotFoundError:
pass
try:
net_type.save()
except Exception, e:
self.log.error(u'Failed to insert network type.')
raise VlanError(e, u'Failed to insert network type.')
net_type_map = dict()
net_type_map['id'] = net_type.id
return self.response(dumps_networkapi({'net_type': net_type_map}))
def handle_post(self, request, user, *args, **kwargs):
"""Treat requests POST to insert a Equipment Type.
URL: equipmenttype/
"""
try:
self.log.info("Add Equipment Script")
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_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:
msg = u'There is no value to the networkapi tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
equipment_type_map = networkapi_map.get('equipment_type')
if equipment_type_map is None:
msg = u'There is no value to the equipment_type tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
# Get XML data
name = equipment_type_map.get('name')
# Valid Name
if not is_valid_string_minsize(name, 3) or not is_valid_string_maxsize(name, 100) or not is_valid_regex(name, "^[A-Za-z0-9 -]+$"):
self.log.error(u'Parameter name is invalid. Value: %s', name)
raise InvalidValueError(None, 'name', name)
# Business Rules
equipment_type = TipoEquipamento()
# save Equipment Type
equipment_type.insert_new(user, name)
etype_dict = dict()
etype_dict['id'] = equipment_type.id
return self.response(dumps_networkapi({'equipment_type': etype_dict}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_put(self, request, user, *args, **kwargs):
"""Handle POST requests to get Environments by template name.
URLs: /environment/get_env_template/,
"""
try:
if not has_perm(user, AdminPermission.VLAN_MANAGEMENT,
AdminPermission.READ_OPERATION):
return self.not_authorized()
environment_list = list()
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.'
)
map = networkapi_map.get('map')
if map is None:
return self.response_error(
3,
u'Não existe valor para a tag ambiente do XML de requisição.'
)
name = map.get('name')
network = map.get('network')
if network == IP_VERSION.IPv4[1]:
environments = Ambiente.objects.filter(ipv4_template=name)
elif network == IP_VERSION.IPv6[1]:
environments = Ambiente.objects.filter(ipv6_template=name)
else:
return self.response_error(269, 'network', network)
if environments:
for env in environments:
environment_list.append(env.divisao_dc.nome + '-' +
env.ambiente_logico.nome + '-' +
env.grupo_l3.nome)
return self.response(
dumps_networkapi({'ambiente': environment_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 Invalidate a vlan
URL: vlan/<id_vlan>/invalidate/<network>
'''
try:
id_vlan = kwargs.get('id_vlan')
network = kwargs.get('network')
# User permission
if not has_perm(user, AdminPermission.ACL_VLAN_VALIDATION,
AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
# Valid Vlan ID
if not is_valid_int_greater_zero_param(id_vlan):
self.log.error(
u'The id_vlan parameter is not a valid value: %s.',
id_vlan)
raise InvalidValueError(None, 'vlan_id', id_vlan)
# Valid Network
if not is_valid_version_ip(network, IP_VERSION):
self.log.error(
u'The network parameter is not a valid value: %s.',
network)
raise InvalidValueError(None, 'network', network)
# Find Vlan by ID to check if it exist
vlan = Vlan().get_by_pk(id_vlan)
with distributedlock(LOCK_VLAN % id_vlan):
# Set Values
if network == IP_VERSION.IPv4[0]:
vlan.acl_valida = 0
vlan.acl_file_name = None
else:
vlan.acl_valida_v6 = 0
vlan.acl_file_name_v6 = None
vlan.save()
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 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_get(self, request, user, *args, **kwargs):
'''Trata as requisições de GET para listar Usuarios.
URLs: usuario/get/$
'''
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.READ_OPERATION):
return self.not_authorized()
list_groups = []
user_groups_list = []
map_list = []
for user in Usuario.objects.all():
user_map = dict()
user_map['id'] = user.id
user_map['user'] = user.user
user_map['nome'] = user.nome
user_map['ativo'] = user.ativo
user_map['email'] = user.email
groups = None
groups = UsuarioGrupo.list_by_user_id(user.id)
if groups is not None and len(groups) > 0:
for group in groups:
user_groups_list.append(
UGrupo.get_by_pk(group.ugrupo_id))
for user_group in user_groups_list:
list_groups.append(user_group.nome)
if (len(list_groups) > 3):
user_map['is_more'] = True
else:
user_map['is_more'] = False
user_map['grupos'] = list_groups if len(list_groups) > 0 else [
None
]
list_groups = []
user_groups_list = []
map_list.append(user_map)
return self.response(dumps_networkapi({'usuario': map_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except (UsuarioError, GrupoError):
return self.response_error(1)
def handle_post(self, request, user, *args, **kwargs):
"""Treat requests POST to add Rack.
URL: interface/associar-ambiente/
"""
try:
self.log.info('Associa interface aos ambientes')
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
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.'
)
interface_map = networkapi_map.get('interface')
if interface_map is None:
return self.response_error(
3,
u'There is no value to the interface tag of XML request.')
# Get XML data
env = interface_map.get('ambiente')
interface = interface_map.get('interface')
amb_int = EnvironmentInterface()
interfaces = Interface()
amb = Ambiente()
amb_int.interface = interfaces.get_by_pk(int(interface))
amb_int.ambiente = amb.get_by_pk(int(env))
amb_int.create(user)
amb_int_map = dict()
amb_int_map['interface_ambiente'] = amb_int
return self.response(dumps_networkapi(amb_int_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_post(self, request, user, *args, **kwargs):
"""Treat requests POST to insert Option VIP.
URL: optionvip/
"""
try:
self.log.info('Add Option VIP')
# 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)
# 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.'
)
optionvip_map = networkapi_map.get('option_vip')
if optionvip_map is None:
return self.response_error(
3,
u'There is no value to the option_vip tag of XML request.'
)
# New Option Vip
option_vip = OptionVip()
# Valid Option Vip
option_vip.valid_option_vip(optionvip_map)
try:
# Save Option Vip
option_vip.save()
except Exception, e:
self.log.error(u'Failed to save the option vip.')
raise OptionVipError(e, u'Failed to save the option vip')
option_map = dict()
option_map['option_vip'] = model_to_dict(option_vip, fields=['id'])
return self.response(dumps_networkapi(option_map))
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_put(self, request, user, *args, **kwargs):
"""Trata uma requisição PUT para alterar tipos de rede.
URL: /tiporede/<id_tipo_rede>/
"""
# Obtém dados do request e verifica acesso
try:
# Verificar a permissão
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
# Obtém argumentos passados na URL
id_tipo_rede = kwargs.get('id_tipo_rede')
if id_tipo_rede is None:
return self.response_error(256)
# Obtém dados do XML
xml_map, attrs_map = loads(request.raw_post_data)
# Obtém o mapa correspondente ao root node do mapa do XML
# (networkapi)
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.'
)
# Verifica a existência do node "tipo_rede"
tipo_rede_map = networkapi_map.get('tipo_rede')
if tipo_rede_map is None:
return self.response_error(
3,
u'Não existe valor para a tag tipo_rede do XML de requisição.'
)
# Verifica a existência do valor "fqdn"
nome = tipo_rede_map.get('nome')
if nome is None:
return self.response_error(176)
# Altera o tipo de redeconforme dados recebidos no XML
TipoRede.update(user, id_tipo_rede, tipo_rede=nome)
# Retorna response vazio em caso de sucesso
return self.response(dumps_networkapi({}))
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
def handle_put(self, request, user, *args, **kwargs):
"""Treat PUT requests to edit Filters.
URL: filter/<id_filter>/
"""
try:
self.log.info('Alter 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()
# 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.'
)
filter_map = networkapi_map.get('filter')
if filter_map is None:
return self.response_error(
3, u'There is no value to the filter tag of XML request.')
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'])
fil.validate_filter(filter_map)
try:
# Save filter
fil.save()
except Exception, e:
self.log.error(u'Failed to edit the filter.')
raise e
return self.response(dumps_networkapi({}))
def get_envs(self, user, no_blocks=False):
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
# Business Rules
# Get all environments in DB
environments = Ambiente.objects.all().order_by('divisao_dc__nome', 'ambiente_logico__nome',
'grupo_l3__nome').select_related('grupo_l3', 'ambiente_logico', 'divisao_dc', 'filter')
lists = []
if not no_blocks:
use_env = 1
else:
use_env = 0
for env in environments:
if no_blocks:
if env.blockrules_set.count() != 0:
use_env = 0
if use_env:
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
if not env.min_num_vlan_1 is None and not env.max_num_vlan_2 is None:
env_map['range'] = str(
env.min_num_vlan_1) + ' - ' + str(env.max_num_vlan_2)
else:
env_map['range'] = 'Nao definido'
if env.filter is not None:
env_map['filter_name'] = env.filter.name
lists.append(env_map)
if not env.min_num_vlan_1 is None and not env.max_num_vlan_2 is None:
env_map['range'] = str(
env.min_num_vlan_1) + ' - ' + str(env.max_num_vlan_2)
else:
env_map['range'] = 'Nao definido'
# Return XML
environment_list = dict()
environment_list['ambiente'] = lists
return self.response(dumps_networkapi(environment_list))
except GrupoError:
return self.response_error(1)
def handle_get(self, request, user, *args, **kwargs):
"""Handles GET requests to search VLAN by ID.
Network IPv4/IPv6 related will also be fetched.
URLs: /vlan/<id_vlan>/network/
"""
self.log.info('Search VLAN by ID')
try:
# Commons Validations
# User permission
if not has_perm(user, AdminPermission.VLAN_MANAGEMENT,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
# Business Validations
# Load URL param
vlan_id = kwargs.get('id_vlan')
# Valid VLAN ID
if not is_valid_int_greater_zero_param(vlan_id):
self.log.error(u'Parameter id_vlan is invalid. Value: %s.',
vlan_id)
raise InvalidValueError(None, 'id_vlan', vlan_id)
# Existing VLAN ID
vlan = Vlan().get_by_pk(vlan_id)
# Get all network_ipv4/ipv6 related to vlan
try:
network_ipv4 = NetworkIPv4.objects.filter(
vlan=vlan).order_by('id')
network_ipv6 = NetworkIPv6.objects.filter(
vlan=vlan).order_by('id')
except Exception, e:
self.log.error(
u'Error finding the first network_ipv4 from vlan.')
raise NetworkIPv4NotFoundError(
e, u'Error finding the first network_ipv4 from vlan.')
vlan_map = self.get_vlan_map(vlan, network_ipv4, network_ipv6)
map = dict()
map['vlan'] = vlan_map
return self.response(dumps_networkapi(map))
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_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find Rule by id.
URL: /rule/get_by_id/<id_rule>
"""
try:
# User permission
if not has_perm(user, AdminPermission.VIPS_REQUEST,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
id_rule = kwargs.get('id_rule')
if not is_valid_int_greater_zero_param(id_rule):
self.log.error(u'Parameter id_rule is invalid. Value: %s.',
id_rule)
raise InvalidValueError(None, 'id_rule', id_rule)
rule = Rule.objects.get(pk=id_rule)
contents = RuleContent.objects.filter(rule=rule)
rule_contents = list()
rule_blocks = list()
for content in contents:
block_id = 0
try:
block = BlockRules.objects.get(
content=content.content,
environment=content.rule.environment)
block_id = block.id
except Exception:
pass
rule_contents.append(content.content)
rule_blocks.append(block_id)
return self.response(
dumps_networkapi({
'rule': {
'name': rule.name,
'rule_contents': rule_contents,
'rule_blocks': rule_blocks
}
}))
except InvalidValueError, e:
self.log.error('Invalid param')
return self.response_error(269, e.param, e.value)
def handle_post(self, request, user, *args, **kwargs):
"""Treat POST requests to add new Filter.
URL: filter/
"""
try:
self.log.info('Add 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()
# 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.'
)
filter_map = networkapi_map.get('filter')
if filter_map is None:
return self.response_error(
3, u'There is no value to the filter tag of XML request.')
# New Filter
filter_ = Filter()
# Validates
filter_.validate_filter(filter_map)
try:
# Save filter
filter_.save()
except Exception, e:
self.log.error(u'Failed to save the filter.')
raise FilterError(e, u'Failed to save the filter')
filter_map = dict()
filter_map['id'] = filter_.id
return self.response(dumps_networkapi({'filter': filter_map}))
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para consulta de ambientes.
Permite a consulta de todos os ambientes, ambientes filtrados por divisao_dc,
ambientes filtrados por divisão_dc e por ambiente_logico
URLs: /ambiente/,
/ambiente/divisao_dc/<id_divisao_dc>/,
/ambiente/divisao_dc/<id_divisao_dc>/ambiente_logico/<id_amb_logico>/,
"""
try:
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT,
AdminPermission.READ_OPERATION):
return self.not_authorized()
environment_list = []
division_id = kwargs.get('id_divisao_dc')
environment_logical_id = kwargs.get('id_amb_logico')
if division_id is not None:
if not is_valid_int_greater_zero_param(division_id):
self.log.error(
u'The division_id parameter is not a valid value: %s.',
division_id)
raise InvalidValueError(None, 'division_id', division_id)
else:
division_dc = DivisaoDc.get_by_pk(division_id)
if environment_logical_id is not None:
if not is_valid_int_greater_zero_param(environment_logical_id):
self.log.error(
u'The environment_logical_id parameter is not a valid value: %s.',
environment_logical_id)
raise InvalidValueError(None, 'environment_logical_id',
environment_logical_id)
else:
loc_env = AmbienteLogico.get_by_pk(environment_logical_id)
environments = Ambiente().search(
division_id,
environment_logical_id).select_related('grupo_l3',
'ambiente_logico',
'divisao_dc', 'filter')
for environment in environments:
environment_list.append(get_environment_map(environment))
return self.response(
dumps_networkapi({'ambiente': environment_list}))
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 inserir direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
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)
if response is not None:
return response
direito = DireitosGrupoEquipamento()
direito.egrupo = EGrupo(id=direito_map.get('id_grupo_equipamento'))
direito.ugrupo = UGrupo(id=direito_map.get('id_grupo_usuario'))
direito.leitura = direito_map.get('leitura')
direito.escrita = direito_map.get('escrita')
direito.alterar_config = direito_map.get('alterar_config')
direito.exclusao = direito_map.get('exclusao')
direito.create(user)
return self.response(
dumps_networkapi(
{'direito_grupo_equipamento': {
'id': direito.id
}}))
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all healthcheck of the Option VIP by Environment Vip.
URL: environment-vip/get/heathcheck/<id_evip>
"""
try:
self.log.info(
'GET to list all healthcheck of the Option VIP by Environment Vip.'
)
# 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)
ovips = OptionVip.get_all_healthcheck(environment_vip.id)
ovip_list = []
for ovip in ovips:
ovip_dict = dict()
ovip_dict['id_opt_vip'] = ovip.id
ovip_dict['name'] = str(ovip.nome_opcao_txt).upper()
ovip_list.append(ovip_dict)
return self.response(
dumps_networkapi({'healthcheck_opt': ovip_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_post(self, request, user, *args, **kwargs):
"""Treat requests POST to add a HeltcheckExpect only expect_string field.
URL: healthcheckexpect/add/expectstring/
"""
try:
# 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:
msg = u'There is no value to the networkapi tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
healthcheck_map = networkapi_map.get('healthcheck')
if healthcheck_map is None:
msg = u'There is no value to the ip tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
# Get XML data
expect_string = healthcheck_map.get('expect_string')
if not is_valid_string_maxsize(expect_string, 50):
self.log.error(
u'Parameter expect_string is invalid. Value: %s.',
expect_string)
raise InvalidValueError(None, 'expect_string', expect_string)
# User permission
if not has_perm(user, AdminPermission.HEALTH_CHECK_EXPECT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
healthcheck = HealthcheckExpect()
healthcheck.insert_expect_string(user, expect_string)
healtchcheck_dict = dict()
healtchcheck_dict['id'] = healthcheck.id
return self.response(
dumps_networkapi({'healthcheck_expect': healtchcheck_dict}))
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 criar tipos de rede.
URL: /tiporede/
"""
# Obtém dados do request e verifica acesso
try:
# Verificar a permissão
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
# Obtém os dados do xml do request
xml_map, attrs_map = loads(request.raw_post_data)
# Obtém o mapa correspondente ao root node do mapa do XML
# (networkapi)
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.')
# Verifica a existência do node "tipo_rede"
tipo_rede_map = networkapi_map.get('tipo_rede')
if tipo_rede_map is None:
return self.response_error(3, u'Não existe valor para a tag tipo_rede do XML de requisição.')
# Verifica a existência do valor "fqdn"
nome = tipo_rede_map.get('nome')
if nome is None:
return self.response_error(176)
# Cria acesso ao equipamento conforme dados recebidos no XML
tipo_rede = TipoRede(tipo_rede=nome)
tipo_rede.create(user)
# Monta dict para response
networkapi_map = dict()
tipo_rede_map = dict()
tipo_rede_map['id'] = tipo_rede.id
networkapi_map['tipo_rede'] = tipo_rede_map
return self.response(dumps_networkapi(networkapi_map))
except TipoRedeNameDuplicatedError:
return self.response_error(253, nome)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Script by Equipment.
URL: script/equipment/<id_equipment>
"""
try:
self.log.info("GET to list all the Script by Equipment")
id_equipment = kwargs.get('id_equipment')
# 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)
# Find Equipment by ID to check if it exist
Equipamento.get_by_pk(id_equipment)
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.READ_OPERATION, None, id_equipment,
AdminPermission.EQUIP_READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
script_list = []
equipment_scripts = EquipamentoRoteiro.search(None, id_equipment)
for equipment_script in equipment_scripts:
script_map = dict()
script_map['id'] = equipment_script.roteiro.id
script_map['nome'] = equipment_script.roteiro.roteiro
script_map['descricao'] = equipment_script.roteiro.descricao
script_map[
'id_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.id
script_map[
'nome_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.tipo
script_map[
'descricao_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.descricao
script_list.append(script_map)
return self.response(dumps_networkapi({'script': script_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 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()
except ObjectDoesNotExist, e:
# Association doesn't exist, ok
self.log.error(e)
pass
return self.response(dumps_networkapi({}))
def handle_put(self, request, user, *args, **kwargs):
""" Handles a PUT request to edit the L7 filter.
URL: vip/<id_vip>/filter/
"""
if not has_perm(user, AdminPermission.VIP_ALTER_SCRIPT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
id_vip = kwargs.get('id_vip')
# 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.')
vip = RequisicaoVips.get_by_pk(id_vip)
# Get XML data
l7_filter = vip_map['l7_filter']
vip.l7_filter = l7_filter
vip.filter_valid = False
# If the l7_filter is a rule, set filter_valid to TRUE
if vip_map.get('rule_id') is not None:
vip.filter_valid = 1
rule = Rule.objects.get(pk=vip_map.get('rule_id'))
vip.l7_filter = '\n'.join(rule.rulecontent_set.all().values_list(
'content', flat=True))
vip.rule = rule
else:
vip.filter_valid = 0
vip.rule = None
vip.save()
map = dict()
map['sucesso'] = 'sucesso'
return self.response(dumps_networkapi(map))
def handle_get(self, request, user, *args, **kwargs):
"""Treat requests GET to list all the Model.
URL: model/all
"""
try:
self.log.info("GET to list all the Model")
script_id = kwargs.get('script_id')
# User permission
if not has_perm(user, AdminPermission.BRAND_MANAGEMENT,
AdminPermission.READ_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
model_list = []
if script_id is not None:
models = ModeloRoteiro.objects.filter(
roteiro__id=int(script_id))
for i in models:
model_list.append(self.model_map(i.modelo))
return self.response(dumps_networkapi({'model': model_list}))
for model in Modelo.objects.all():
model_list.append(self.model_map(model))
return self.response(dumps_networkapi({'model': model_list}))
except UserNotAuthorizedError:
return self.not_authorized()
except EquipamentoError:
return self.response_error(1)
def search_interface_of_equipment(self, equipment_id, is_new):
'''Obtém as interfaces do equipamento'''
# Efetua a consulta das interfaces do equipamento
results = Interface.search(equipment_id)
if results.count() > 0:
# Monta lista com dados retornados
map_list = []
for item in results:
if is_new:
map_list.append(self.get_new_interface_map(item))
else:
map_list.append(self.get_interface_map(item))
# Gera response (XML) com resultados
if is_new:
return self.response(dumps_networkapi({'interfaces': map_list}))
else:
return self.response(dumps_networkapi({'interface': map_list}))
else:
# Gera response (XML) para resultado vazio
return self.response(dumps_networkapi({}))
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_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)
