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)