def update_rack(rack_id, rack):
try:
rack_obj = Rack()
rack_obj = rack_obj.get_rack(idt=rack_id)
rack_obj.nome = rack.get("name")
rack_obj.numero = rack.get("number")
rack_obj.mac_sw1 = rack.get("mac_sw1")
rack_obj.mac_sw2 = rack.get("mac_sw2")
rack_obj.mac_ilo = rack.get("mac_ilo")
rack_obj.id_sw1 = Equipamento().get_by_pk(int(rack.get("id_sw1")))
rack_obj.id_sw2 = Equipamento().get_by_pk(int(rack.get("id_sw2")))
rack_obj.id_ilo = Equipamento().get_by_pk(int(rack.get("id_ilo")))
rack_obj.dcroom = DatacenterRooms().get_dcrooms(idt=rack.get('fabric_id')) if rack.get('fabric_id') \
else None
rack_obj.save()
return rack_obj
except (exceptions.RackNumberDuplicatedValueError,
exceptions.RackNameDuplicatedError,
exceptions.InvalidInputException) as e:
log.exception(e)
raise Exception(e)
except Exception, e:
log.exception(e)
raise Exception(e)
def get_equipment_by_id(equipment_id):
"""Get equipment by id"""
try:
equipment = Equipamento().get_by_pk(equipment_id)
except EquipamentoNotFoundError, e:
raise ObjectDoesNotExistException(e.message)
def test_check_available_ip(self):
ip_equipamento = IpEquipamento(equipamento=Equipamento(
tipo_equipamento=TipoEquipamento(id=1,
tipo_equipamento='balanceador')))
network = self.mock_network(ip_equipamento)
self.mock_user_has_permission(True)
self.mock_get_vip_environment_by_pk(
self.mock_vip_environment(1, 'production env', networks=[network]))
self.mock_network_get_available_ip(IPv4Address('192.168.1.1'))
self.mock_get_tipo_balanceador(
TipoEquipamento(id=1, tipo_equipamento='balanceador'))
ip_save_mock = self.mock_ip_save()
response = self.client.post('/ip/availableip4/vip/1/',
XML % 1,
content_type='text/xml')
print(response)
xml_map = self.parse_response(response)
self.assertEquals('192',
xml_map.get('networkapi').get('ip').get('oct1'))
self.assertEquals('168',
xml_map.get('networkapi').get('ip').get('oct2'))
self.assertEquals('1', xml_map.get('networkapi').get('ip').get('oct3'))
self.assertEquals('1', xml_map.get('networkapi').get('ip').get('oct4'))
self.assertEquals(200, response.status_code)
self.assertTrue(ip_save_mock.called)
def get(self, request, *args, **kwargs):
try:
env_id = kwargs.get('env_id')
data = dict()
if env_id:
log.info('Get Routers by environment.')
routers_list = []
rot_do_ambiente = facade.get_routers_by_environment(
int(env_id))
for r in rot_do_ambiente:
router_id = r.equipamento.id
router = Equipamento().get_by_pk(router_id)
routers_list.append(facade.get_equipment_map(router))
data['routers'] = routers_list
return CustomResponse(data,
status=status.HTTP_200_OK,
request=request)
except ObjectDoesNotExist, exception:
log.error(exception)
raise api_exceptions.ObjectDoesNotExistException(
'Equipment Does Not Exist')
def create_equipment(equipment, user):
"""Create equipment"""
equipment_obj = Equipamento()
equipment_obj.create_v3(equipment)
return equipment_obj
def create_equipment(equipments, user):
"""Create equipment"""
response = list()
try:
for equipment in equipments:
equipment_obj = Equipamento()
equipment_obj.create_v3(equipment)
response.append({'id': equipment_obj.id})
except EquipamentoError, e:
raise ValidationAPIException(e.message)
def save_rack_dc(rack_dict):
rack = Rack()
rack.nome = rack_dict.get('name')
rack.numero = rack_dict.get('number')
rack.mac_sw1 = rack_dict.get('mac_sw1')
rack.mac_sw2 = rack_dict.get('mac_sw2')
rack.mac_ilo = rack_dict.get('mac_ilo')
rack.id_sw1 = Equipamento().get_by_pk(rack_dict.get('id_sw1'))
rack.id_sw2 = Equipamento().get_by_pk(rack_dict.get('id_sw2'))
rack.id_sw3 = Equipamento().get_by_pk(rack_dict.get('id_ilo'))
rack.dcroom = DatacenterRooms().get_dcrooms(
idt=rack_dict.get('fabric_id')) if rack_dict.get('fabric_id') else None
if not rack.nome:
raise exceptions.InvalidInputException(
"O nome do Rack não foi informado.")
rack.save_rack()
return rack
def create_pool_member(self):
pool = self.create_server_pool_model()
member = ServerPoolMember(server_pool=pool,
identifier='member_1',
ip=self.create_ipv4(),
priority=1,
weight=0,
limit=pool.default_limit,
port_real=8080)
member.equipment = Equipamento(
id=1, nome="l-59c0df40-624d-4174-ad7e-a67e54bb3ced")
return member
def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para consulta de um ambiente.
Consulta o ambiente de um IP associado a um Equipamento.
URL: /ambiente/equipamento/<nome_equip>/ip/<x1>.<x2>.<x3>.<x4>/
"""
equipment_name = kwargs.get('nome_equip')
oct1 = kwargs.get('x1')
oct2 = kwargs.get('x2')
oct3 = kwargs.get('x3')
oct4 = kwargs.get('x4')
if equipment_name is None or oct1 is None or oct2 is None or oct3 is None or oct4 is None:
return super(AmbienteEquipamentoResource,
self).handle_get(request, user, *args, **kwargs)
self.log.debug('nome_equip = %s', equipment_name)
self.log.debug('x1 = %s', oct1)
self.log.debug('x2 = %s', oct2)
self.log.debug('x3 = %s', oct3)
self.log.debug('x4 = %s', oct4)
try:
equip = Equipamento().get_by_name(equipment_name)
if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT,
AdminPermission.READ_OPERATION, None, equip.id,
AdminPermission.EQUIP_READ_OPERATION):
return self.not_authorized()
ip = Ip().get_by_octs_equipment(oct1, oct2, oct3, oct4, equip.id)
environment_map = get_environment_map(ip.vlan.ambiente)
map = dict()
map['ambiente'] = environment_map
return self.response(dumps_networkapi(map))
except EquipamentoNotFoundError:
return self.response_error(117, equipment_name)
except IpNotFoundError:
return self.response_error(
118, oct1 + '.' + oct2 + '.' + oct3 + '.' + oct4, equip.id)
except (IpError, EquipamentoError, GrupoError):
return self.response_error(1)
def get_id_ip(real):
"""
Get real id_ip by octs/block and equipment
"""
equip = Equipamento().get_by_name(real['real_name'])
# Check ip type
if is_valid_ipv4(real['real_ip']) is True:
oct = real['real_ip'].split('.')
ip = Ip().get_by_octs_equipment(
oct[0], oct[1], oct[2], oct[3], equip.id)
else:
block = real['real_ip'].split(':')
ip = Ipv6().get_by_blocks_equipment(block[0], block[1], block[2], block[
3], block[4], block[5], block[6], block[7], equip.id)
return ip.id
def test_add_network_given_successfully(self):
self.mock_get_network_type_by_pk(TipoRede(id=1))
self.mock_get_vip_environment_by_pk(EnvironmentVip(id=1))
add_network_mock = self.mock_add_network_ipv4(self.get_vlan_map())
self.mock_get_equipamento_ambiente(
EquipamentoAmbiente(equipamento=Equipamento(id=1)))
self.mock_get_first_available_ip("192.168.10.18")
self.mock_ip_save()
self.mock_ip_equipamento_create()
response = self.client.post("/network/ipv4/add/",
XML.format(cidr='24',
vlan=1,
vip_env=1,
net_type=1),
content_type="text/xml")
xml_map = self.parse_response(response)
self.assertIsNotNone(xml_map.get('networkapi').get('vlan'))
self.assertEquals(200, response.status_code)
self.assertTrue(add_network_mock.called)
def has_perm(user,
perm_function,
perm_oper,
egroup_id=None,
equip_id=None,
equip_oper=None):
"""
@raise EGrupoNotFoundError: Grupo do equipamento nao cadastrado.
@raise EquipamentoNotFoundError: Equipamento nao cadastrado.
@raise GrupoError: Falha ao pesquisar os direitos do grupo-equipamento, ou as permissões administrativas, ou o grupo do equipamento.
@raise EquipamentoError: Falha ao pesquisar o equipamento.
"""
if user is None:
return False
egroups = None
if egroup_id is not None:
egroup = EGrupo.get_by_pk(egroup_id)
egroups = [egroup]
elif equip_id is not None:
equip = Equipamento().get_by_pk(equip_id)
egroups = equip.grupos.all()
if len(egroups) == 0:
return False
ugroups = user.grupos.all()
for ugroup in ugroups:
try:
perm = PermissaoAdministrativa().get_permission(
perm_function, ugroup, perm_oper)
if (egroups is None) or (_has_equip_perm(ugroup, egroups,
equip_oper)):
return True
except PermissaoAdministrativaNotFoundError:
continue
return False
def test_add_network_given_no_first_ip_available(self):
self.mock_get_network_type_by_pk(TipoRede(id=1))
self.mock_get_vip_environment_by_pk(EnvironmentVip(id=1))
add_network_mock = self.mock_add_network_ipv4({'vlan': {}})
self.mock_get_equipamento_ambiente(
EquipamentoAmbiente(equipamento=Equipamento(id=1)))
self.mock_get_first_available_ip(
IpNotAvailableError('Endereço IP não dispoínvel'))
response = self.client.post("/network/ipv4/add/",
XML.format(cidr='24',
vlan=1,
vip_env=1,
net_type=1),
content_type="text/xml")
xml_map = self.parse_response(response)
self.assertEquals(
"Causa: Endereço IP não dispoínvel, Mensagem: None",
xml_map.get('networkapi').get('erro').get('descricao'))
self.assertEquals(500, response.status_code)
self.assertTrue(add_network_mock.called)
def setUp(self):
self.user = Usuario()
self.equipment_list = [Equipamento(id=1, nome='router')]
self.ambiente = Ambiente()
self.vlan = Vlan(id=1, ambiente=self.ambiente)
self.networkv4 = NetworkIPv4(id=1,
vlan=self.vlan,
oct1=192,
oct2=168,
oct3=0,
oct4=0,
mask_oct1=255,
mask_oct2=255,
mask_oct3=255,
mask_oct4=0)
self.networkv6 = NetworkIPv6(id=1,
vlan=self.vlan,
block1='fff',
block2='fff',
block3='fff',
block4='fff',
block5='fff',
block6='fff',
block7='fff',
block8='fff',
mask1='fff',
mask2='fff',
mask3='fff',
mask4='fff',
mask5='fff',
mask6='fff',
mask7='fff',
mask8='fff')
self.mock_distributed_lock()
self.mock_transaction()
def insert_equipment_group(self, equip_id, group_id, user):
equipment_group = EquipamentoGrupo()
equipment_group.egrupo = EGrupo()
equipment_group.egrupo.id = group_id
equipment_group.equipamento = Equipamento()
equipment_group.equipamento.id = equip_id
try:
equipment_group.create(user)
equipment_group_map = dict()
equipment_group_map['id'] = equipment_group.id
map = dict()
map['equipamento_grupo'] = equipment_group_map
return self.response(dumps_networkapi(map))
except EGrupoNotFoundError:
return self.response_error(102)
except EquipamentoGrupoDuplicatedError:
return self.response_error(146)
except (EquipamentoError, GrupoError):
return self.response_error(1)
def test_check_available_ip_given_no_load_balancer_equipment_available_on_network(
self):
ip_equipamento = IpEquipamento(equipamento=Equipamento(
tipo_equipamento=TipoEquipamento(id=2, tipo_equipamento='router')))
network = self.mock_network(ip_equipamento)
self.mock_user_has_permission(True)
self.mock_get_vip_environment_by_pk(
self.mock_vip_environment(1, 'production env', networks=[network]))
self.mock_network_get_available_ip(IPv4Address('192.168.1.1'))
self.mock_get_tipo_balanceador(
TipoEquipamento(id=1, tipo_equipamento='balanceador'))
response = self.client.post('/ip/availableip4/vip/1/',
XML % 1,
content_type='text/xml')
xml_map = self.parse_response(response)
self.assertEquals(
'Não há ipv4 disponivel para as redes associdas com o Ambiente '
'Vip: production env - production env - production env, pois não existe '
'equipamentos do Tipo Balanceador nessas redes.',
xml_map.get('networkapi').get('erro').get('descricao'))
self.assertEquals(500, response.status_code)
def add_remove_check_list_vlan_trunk(self, user, networkapi_map, vlan_id, operation):
equipment_map = networkapi_map.get('equipamento')
if equipment_map is None:
return self.response_error(105)
try:
name = equipment_map.get('nome')
if name is None or name == '':
self.log.error(u'Parameter nome is invalid. Value: %s.', name)
raise InvalidValueError(None, 'nome', name)
interface_name = equipment_map.get('nome_interface')
if interface_name is None or interface_name == '':
self.log.error(
u'Parameter nome_interface is invalid. Value: %s.', interface_name)
raise InvalidValueError(None, 'nome_interface', interface_name)
if operation != 'list':
vlan = Vlan().get_by_pk(vlan_id)
# Check existence
equipment = Equipamento().get_by_name(name)
equip_permission = AdminPermission.EQUIP_UPDATE_CONFIG_OPERATION
admin_permission = AdminPermission.WRITE_OPERATION
if operation in ['check', 'list']:
equip_permission = AdminPermission.EQUIP_READ_OPERATION
admin_permission = AdminPermission.READ_OPERATION
if not has_perm(user,
AdminPermission.VLAN_ALTER_SCRIPT,
admin_permission,
None,
equipment.id,
equip_permission):
return self.not_authorized()
interface = Interface.get_by_interface_equipment(
interface_name, equipment.id)
if interface.ligacao_front is None:
return self.response_error(139)
protected = None
if operation not in ['check', 'list']:
protected = 0
try:
switch_interface = interface.get_switch_interface_from_host_interface(
protected)
except InterfaceNotFoundError:
return self.response_error(144)
if not has_perm(user,
AdminPermission.VLAN_ALTER_SCRIPT,
admin_permission,
None,
switch_interface.equipamento_id,
equip_permission):
return self.not_authorized()
# configurador -T snmp_vlans_trunk -i <nomequip> -A “'int=<interface> add=<numvlan>'”
# configurador -T snmp_vlans_trunk -i <nomequip> -A “'int=<interface> del=<numvlan>'”
# configurador -T snmp_vlans_trunk -i <nomequip> -A “'int=<interface> check=<numvlan>'"
# configurador -T snmp_vlans_trunk -i <nomequip> -A
# “'int=<interface> list'"
command = 'configurador -T snmp_vlans_trunk -i %s -A "\'int=%s %s' % (switch_interface.equipamento.nome,
switch_interface.interface,
operation)
if operation != 'list':
command = command + '=%d' % vlan.num_vlan
command = command + '\'"'
code, stdout, stderr = exec_script(command)
if code == 0:
map = dict()
success_map = dict()
success_map['codigo'] = '%04d' % code
success_map['descricao'] = {'stdout': stdout, 'stderr': stderr}
map['sucesso'] = success_map
return self.response(dumps_networkapi(map))
else:
return self.response_error(2, stdout + stderr)
except EquipamentoNotFoundError:
return self.response_error(117, name)
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 Informações de Acesso a Equipamentos.
URL: /equipamentoacesso
"""
# Obtém dados do request e verifica acesso
try:
# 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 "equipamento_acesso"
equipamento_acesso_map = networkapi_map.get('equipamento_acesso')
if equipamento_acesso_map is None:
return self.response_error(
3,
u'Não existe valor para a tag equipamento_acesso do XML de requisição.'
)
# Verifica a existência do valor "id_equipamento"
id_equipamento = equipamento_acesso_map.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)
try:
id_equipamento = int(id_equipamento)
except (TypeError, ValueError):
self.log.error(u'Valor do id_equipamento inválido: %s.',
id_equipamento)
return self.response_error(117, id_equipamento)
# 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()
# Verifica a existência do valor "fqdn"
fqdn = equipamento_acesso_map.get('fqdn')
# Valid fqdn
if not is_valid_string_maxsize(
fqdn, 100) or not is_valid_string_minsize(fqdn, 4):
self.log.error(u'Parameter fqdn is invalid. Value: %s', fqdn)
raise InvalidValueError(None, 'fqdn', fqdn)
# Verifica a existência do valor "user"
username = equipamento_acesso_map.get('user')
# Valid username
if not is_valid_string_maxsize(
username, 20) or not is_valid_string_minsize(username, 3):
self.log.error(u'Parameter username is invalid. Value: %s',
username)
raise InvalidValueError(None, 'username', username)
# Verifica a existência do valor "pass"
password = equipamento_acesso_map.get('pass')
# Valid password
if not is_valid_string_maxsize(
password, 150) or not is_valid_string_minsize(password, 3):
self.log.error(u'Parameter password is invalid.')
raise InvalidValueError(None, 'password', '****')
# Verifica a existência do valor "id_tipo_acesso"
id_tipo_acesso = equipamento_acesso_map.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)
try:
id_tipo_acesso = int(id_tipo_acesso)
except (TypeError, ValueError):
self.log.error(u'Valor do id_tipo_acesso inválido: %s.',
id_tipo_acesso)
return self.response_error(171, id_tipo_acesso)
# Obtém o valor de "enable_pass"
enable_pass = equipamento_acesso_map.get('enable_pass')
# Valid enable_pass
if not is_valid_string_maxsize(enable_pass,
150) or not is_valid_string_minsize(
enable_pass, 3):
self.log.error(u'Parameter enable_pass is invalid.')
raise InvalidValueError(None, 'enable_pass', '****')
# Cria acesso ao equipamento conforme dados recebidos no XML
equipamento_acesso = EquipamentoAcesso(
equipamento=Equipamento(id=id_equipamento),
fqdn=fqdn,
user=username,
password=password,
tipo_acesso=TipoAcesso(id=id_tipo_acesso),
enable_pass=enable_pass)
equipamento_acesso.create(user)
# Monta dict para response
networkapi_map = dict()
equipamento_acesso_map = dict()
equipamento_acesso_map['id'] = equipamento_acesso.id
networkapi_map['equipamento_acesso'] = equipamento_acesso_map
return self.response(dumps_networkapi(networkapi_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_post(self, request, user, *args, **kwargs):
"""Trata uma requisicao POST para editar um equipamento.
URL: equipmento/edit/
"""
try:
# 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)
equip_map = networkapi_map.get('equipamento')
if equip_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
equip_id = equip_map.get('id_equip')
id_modelo = equip_map.get('id_modelo')
nome = equip_map.get('nome')
id_tipo_equipamento = equip_map.get('id_tipo_equipamento')
maintenance = equip_map.get('maintenance')
# Valid equip_id
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(u'Parameter equip_id is invalid. Value: %s.',
equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
# Valid id_modelo
if not is_valid_int_greater_zero_param(id_modelo):
self.log.error(u'Parameter id_modelo is invalid. Value: %s.',
id_modelo)
raise InvalidValueError(None, 'id_modelo', id_modelo)
# Valid id_tipo_equipamento
if not is_valid_int_greater_zero_param(id_tipo_equipamento):
self.log.error(
u'Parameter id_tipo_equipamento is invalid. Value: %s.',
id_tipo_equipamento)
raise InvalidValueError(None, 'id_tipo_equipamento',
id_tipo_equipamento)
# Valid nome
if not is_valid_string_minsize(
nome, 3) or not is_valid_string_maxsize(
nome, 80) or not is_valid_regex(nome, '^[A-Z0-9-_]+$'):
self.log.error(u'Parameter nome is invalid. Value: %s', nome)
raise InvalidValueError(None, 'nome', nome)
# Business Rules
# New equipment
equip = Equipamento()
equip = equip.get_by_pk(equip_id)
# maintenance is a new feature. Check existing value if not defined in request
# Old calls does not send this field
if maintenance is None:
maintenance = equip.maintenance
if not is_valid_boolean_param(maintenance):
self.log.error(
u'The maintenance parameter is not a valid value: %s.',
maintenance)
raise InvalidValueError(None, 'maintenance', maintenance)
if maintenance in ['1', 'True', True]:
maintenance = True
else:
maintenance = False
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION, None, equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None,
u'User does not have permission to perform the operation.')
with distributedlock(LOCK_EQUIPMENT % equip_id):
tipo_equip = TipoEquipamento.get_by_pk(id_tipo_equipamento)
if equip.tipo_equipamento != tipo_equip:
# Environments with filters using current equip type, with
# equipment associated
envs = [
eq_env.ambiente.id
for eq_env in equip.equipamentoambiente_set.filter(
ambiente__filter__filterequiptype__equiptype=equip.
tipo_equipamento)
]
# Filters case 1 and 2
filters_ok = True
# Networks in environments with same ip range
nets_same_range = NetworkIPv4.objects.filter(
vlan__ambiente__in=envs).values(
'oct1', 'oct2', 'oct3', 'oct4', 'block').annotate(
count=Count('id')).filter(count__gt=1)
if len(nets_same_range) > 0:
for net_gp in nets_same_range:
nets_current_range = NetworkIPv4.objects.filter(
vlan__ambiente__in=envs,
oct1=net_gp['oct1'],
oct2=net_gp['oct2'],
oct3=net_gp['oct3'],
oct4=net_gp['oct4'],
block=net_gp['block'])
filters_of_envs = [
net.vlan.ambiente.filter.id
for net in nets_current_range
]
for fil_ in filters_of_envs:
if TipoEquipamento.objects.filter(
id=id_tipo_equipamento,
filterequiptype__filter=fil_).count(
) == 0:
filters_ok = False
break
if not filters_ok:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois existe um filtro em uso que não possui o novo tipo de equipamento informado.'
)
# Networks ipv6 in environments with same ipv6 range
nets_v6_same_range = NetworkIPv6.objects.filter(
vlan__ambiente__in=envs).values(
'block1', 'block2', 'block3', 'block4', 'block5',
'block6', 'block7', 'block8', 'block').annotate(
count=Count('id')).filter(count__gt=1)
if len(nets_v6_same_range) > 0:
for net_gp in nets_v6_same_range:
nets_current_range = NetworkIPv6.objects.filter(
vlan__ambiente__in=envs,
block1=net_gp['block1'],
block2=net_gp['block2'],
block3=net_gp['block3'],
block4=net_gp['block4'],
block5=net_gp['block5'],
block6=net_gp['block6'],
block7=net_gp['block7'],
block8=net_gp['block8'],
block=net_gp['block'])
filters_of_envs = [
net.vlan.ambiente.filter.id
for net in nets_current_range
]
for fil_ in filters_of_envs:
if TipoEquipamento.objects.filter(
id=id_tipo_equipamento,
filterequiptype__filter=fil_).count(
) == 0:
filters_ok = False
break
if not filters_ok:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois existe um filtro em uso que não possui o novo tipo de equipamento informado.'
)
# Filters case 1 and 2 end
# Filter case 3
# Get vlans with same number
vlans_same_number = Vlan.objects.filter(
ambiente__in=envs).values('num_vlan').annotate(
count=Count('id')).filter(count__gt=1)
if len(vlans_same_number) > 0:
for vlan_gp in vlans_same_number:
vlans_current_number = Vlan.objects.filter(
ambiente__in=envs,
num_vlan=vlan_gp['num_vlan'])
filters_of_envs = [
vlan.ambiente.filter.id
for vlan in vlans_current_number
]
for fil_ in filters_of_envs:
if TipoEquipamento.objects.filter(
id=id_tipo_equipamento,
filterequiptype__filter=fil_).count(
) == 0:
filters_ok = False
break
if not filters_ok:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois existe um filtro em uso que não possui o novo tipo de equipamento informado.'
)
# Filter case 3 end
# Test all vip requests if equip.tipo_equipamento is
# balancing
if equip.tipo_equipamento == TipoEquipamento.get_tipo_balanceador(
):
vips = RequisicaoVips.objects.all()
vip_ips = []
vip_ipsv6 = []
for vip in vips:
if vip.vip_criado:
if vip.ip is not None:
if vip.ip.ipequipamento_set.filter(
equipamento=equip.id).count() > 0:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois este equipamento é o balanceador associado com o vip criado %s.'
% vip.id)
if vip.ipv6 is not None:
if vip.ipv6.ipv6equipament_set.filter(
equipamento=equip.id).count() > 0:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois este equipamento é o balanceador associado com o vip criado %s.'
% vip.id)
else:
if vip.ip is not None:
vip_ips.append(vip.ip.id)
if vip.ipv6 is not None:
vip_ipsv6.append(vip.ipv6.id)
nets_using_balancer_in_vips_ = [
ip_.networkipv4
for ip_ in Ip.objects.filter(id__in=vip_ips)
]
nets_using_balancer_in_vips = [
ip_.networkipv4 for ip_ in Ip.objects.filter(
networkipv4__in=nets_using_balancer_in_vips_,
ipequipamento__equipamento=equip.id)
]
nets_v6_using_balancer_in_vips_ = [
ip_.networkipv6
for ip_ in Ipv6.objects.filter(id__in=vip_ipsv6)
]
nets_v6_using_balancer_in_vips = [
ip_.networkipv6 for ip_ in Ipv6.objects.filter(
networkipv6__in=nets_v6_using_balancer_in_vips_,
ipv6equipament__equipamento=equip.id)
]
for net in nets_using_balancer_in_vips:
net_str = str(net.oct1) + '.' + str(net.oct2) + '.' + \
str(net.oct3) + '.' + str(net.oct4) + \
'/' + str(net.block)
if IpEquipamento.objects.filter(
ip__networkipv4=net,
equipamento__tipo_equipamento=TipoEquipamento
.get_tipo_balanceador()).exclude(
equipamento=equip).count() == 0:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois este equipamento é o único balanceador disponível na rede %s da vlan %s.'
% (net_str, net.vlan.nome))
for net in nets_v6_using_balancer_in_vips:
net_str = str(net.block1) + ':' + str(
net.block2
) + ':' + str(net.block3) + ':' + str(
net.block4) + ':' + str(
net.block5) + ':' + str(
net.block6) + ':' + str(
net.block7) + ':' + str(
net.block8) + '/' + str(
net.block)
if Ipv6Equipament.objects.filter(
ip__networkipv6=net,
equipamento__tipo_equipamento=TipoEquipamento
.get_tipo_balanceador()).exclude(
equipamento=equip).count() == 0:
raise EquipTypeCantBeChangedError(
None,
'O tipo de equipamento não pode ser modificado pois este equipamento é o único balanceador disponível na rede %s da vlan %s.'
% (net_str, net.vlan.nome))
ip_equipamento_list = IpEquipamento.objects.filter(
equipamento=equip_id)
ip6_equipamento_list = Ipv6Equipament.objects.filter(
equipamento=equip_id)
# Delete vlan's cache
key_list = []
for eq in ip_equipamento_list:
vlan = eq.ip.networkipv4.vlan
vlan_id = vlan.id
key_list.append(vlan_id)
for eq in ip6_equipamento_list:
vlan = eq.ip.networkipv6.vlan
vlan_id = vlan.id
key_list.append(vlan_id)
destroy_cache_function(key_list)
# Delete equipment's cache
destroy_cache_function([equip_id], True)
modelo = Modelo.get_by_pk(id_modelo)
equip.edit(user, nome, tipo_equip, modelo, maintenance)
return self.response(dumps_networkapi({}))
except EquipTypeCantBeChangedError, e:
return self.response_error(150, e.message)
def get_equipment_by_id(equipment_id):
"""Get equipment by id"""
equipment = Equipamento().get_by_pk(equipment_id)
return equipment
def handle_post(self, request, user, *args, **kwargs):
'''Handles POST requests to associate and IP to an equipment.
URL: ipv4/assoc/
'''
self.log.info('Associate Ip to an Equipment')
try:
# 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)
ip_map = networkapi_map.get('ip_map')
if ip_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
ip_id = ip_map.get('id_ip')
equip_id = ip_map.get('id_equip')
network_ipv4_id = ip_map.get('id_net')
# Valid ip_id
if not is_valid_int_greater_zero_param(ip_id):
self.log.error(
u'Parameter ip_id is invalid. Value: %s.', ip_id)
raise InvalidValueError(None, 'ip_id', ip_id)
# Valid equip_id
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'Parameter equip_id is invalid. Value: %s.', equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
# Valid network_ipv4_id
if not is_valid_int_greater_zero_param(network_ipv4_id):
self.log.error(
u'Parameter network_ipv4_id is invalid. Value: %s.', network_ipv4_id)
raise InvalidValueError(
None, 'network_ipv4_id', network_ipv4_id)
# User permission
if not has_perm(user,
AdminPermission.IPS,
AdminPermission.WRITE_OPERATION,
None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None, u'User does not have permission to perform the operation.')
# Business Rules
# Get net
net = NetworkIPv4.get_by_pk(network_ipv4_id)
with distributedlock(LOCK_NETWORK_IPV4 % network_ipv4_id):
# Get ip
ip = Ip.get_by_pk(ip_id)
# Get equipment
equip = Equipamento.get_by_pk(equip_id)
listaVlansDoEquip = []
for ipequip in equip.ipequipamento_set.all():
vlan = ipequip.ip.networkipv4.vlan
if vlan not in listaVlansDoEquip:
listaVlansDoEquip.append(vlan)
for ipequip in equip.ipv6equipament_set.all():
vlan = ipequip.ip.networkipv6.vlan
if vlan not in listaVlansDoEquip:
listaVlansDoEquip.append(vlan)
vlan_atual = net.vlan
vlan_aux = None
ambiente_aux = None
for vlan in listaVlansDoEquip:
if vlan.num_vlan == vlan_atual.num_vlan:
if vlan.id != vlan_atual.id:
# Filter case 3 - Vlans with same number cannot
# share equipments ##
flag_vlan_error = False
# Filter testing
if vlan.ambiente.filter is None or vlan_atual.ambiente.filter is None:
flag_vlan_error = True
else:
# Test both environment's filters
tp_equip_list_one = list()
for fet in FilterEquipType.objects.filter(filter=vlan_atual.ambiente.filter.id):
tp_equip_list_one.append(fet.equiptype)
tp_equip_list_two = list()
for fet in FilterEquipType.objects.filter(filter=vlan.ambiente.filter.id):
tp_equip_list_two.append(fet.equiptype)
#Equipment type should be in both filters
if equip.tipo_equipamento not in tp_equip_list_one or equip.tipo_equipamento not in tp_equip_list_two:
flag_vlan_error = True
#Out of band network is never trunked, it is only in mgmt interface
# allow it - not a good thing to to, but is very specific
if vlan.ambiente.divisao_dc.nome == 'OOB-CM' or vlan_atual.ambiente.divisao_dc.nome == 'OOB-CM':
flag_vlan_error = False
## Filter case 3 - end ##
if flag_vlan_error:
ambiente_aux = vlan.ambiente
vlan_aux = vlan
nome_ambiente = "%s - %s - %s" % (
vlan.ambiente.divisao_dc.nome, vlan.ambiente.ambiente_logico.nome, vlan.ambiente.grupo_l3.nome)
raise VlanNumberNotAvailableError(None,
'''O ip informado não pode ser cadastrado, pois o equipamento %s, faz parte do ambiente %s (id %s),
que possui a Vlan de id %s, que também possui o número %s, e não é permitido que vlans que compartilhem o mesmo ambiente
por meio de equipamentos, possuam o mesmo número, edite o número de uma das Vlans ou adicione um filtro no ambiente para efetuar o cadastro desse IP no Equipamento Informado.
''' % (equip.nome, nome_ambiente, ambiente_aux.id, vlan_aux.id, vlan_atual.num_vlan))
# Persist
try:
try:
ipEquip = IpEquipamento()
ipEquip.get_by_ip_equipment(ip.id, equip_id)
# Ip %s.%s.%s.%s already has association with
# Equipament %s.' % (self.oct1, self.oct2, self.oct3,
# self.oct4,equipment_id)
raise IpEquipmentAlreadyAssociation(None, u'Ip %s.%s.%s.%s already has association with Equipament %s.' % (
ip.oct1, ip.oct2, ip.oct3, ip.oct4, equip_id))
except IpEquipmentNotFoundError, e:
pass
equipment = Equipamento().get_by_pk(equip_id)
ip_equipment = IpEquipamento()
ip_equipment.ip = ip
ip_equipment.equipamento = equipment
# Filter case 2 - Adding new IpEquip for a equip that
# already have ip in other network with the same range ##
# Get all IpEquipamento related to this equipment
ip_equips = IpEquipamento.objects.filter(
equipamento=equip_id)
for ip_test in [ip_equip.ip for ip_equip in ip_equips]:
if ip_test.networkipv4.oct1 == ip.networkipv4.oct1 and \
ip_test.networkipv4.oct2 == ip.networkipv4.oct2 and \
ip_test.networkipv4.oct3 == ip.networkipv4.oct3 and \
ip_test.networkipv4.oct4 == ip.networkipv4.oct4 and \
ip_test.networkipv4.block == ip.networkipv4.block and \
ip_test.networkipv4 != ip.networkipv4:
# Filter testing
if ip_test.networkipv4.vlan.ambiente.filter is None or ip.networkipv4.vlan.ambiente.filter is None:
raise IpRangeAlreadyAssociation(
None, u'Equipment is already associated with another ip with the same ip range.')
else:
# Test both environment's filters
tp_equip_list_one = list()
for fet in FilterEquipType.objects.filter(filter=ip.networkipv4.vlan.ambiente.filter.id):
tp_equip_list_one.append(fet.equiptype)
tp_equip_list_two = list()
for fet in FilterEquipType.objects.filter(filter=ip_test.networkipv4.vlan.ambiente.filter.id):
tp_equip_list_two.append(fet.equiptype)
if equipment.tipo_equipamento not in tp_equip_list_one or equipment.tipo_equipamento not in tp_equip_list_two:
raise IpRangeAlreadyAssociation(
None, u'Equipment is already associated with another ip with the same ip range.')
## Filter case 2 - end ##
ip_equipment.save()
# Makes Environment Equipment association
try:
equipment_environment = EquipamentoAmbiente()
equipment_environment.equipamento = equipment
equipment_environment.ambiente = net.vlan.ambiente
equipment_environment.create(user)
# Delete vlan's cache
destroy_cache_function([net.vlan_id])
except EquipamentoAmbienteDuplicatedError, e:
# If already exists, OK !
pass
except IpRangeAlreadyAssociation, e:
raise IpRangeAlreadyAssociation(None, e.message)
def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para criar uma nova interface para o equipamento
URL: /interface/
"""
# Obtém dados do request e verifica acesso
try:
# 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 "interface"
interface_map = networkapi_map.get('interface')
if interface_map is None:
return self.response_error(
3,
u'Não existe valor para a tag interface do XML de requisição.'
)
# Valid id_equipamento value
id_equipamento = interface_map.get('id_equipamento')
if not is_valid_int_greater_zero_param(id_equipamento):
self.log.error(
u'Parameter id_equipamento is invalid. Value: %s',
id_equipamento)
raise InvalidValueError(None, 'id_equipamento', id_equipamento)
else:
id_equipamento = int(id_equipamento)
# Check existence
Equipamento.get_by_pk(id_equipamento)
# Verify permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION, None,
id_equipamento,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
# Valid name value
nome = interface_map.get('nome')
if not is_valid_string_minsize(
nome, 1) or not is_valid_string_maxsize(nome, 20):
self.log.error(u'Parameter nome is invalid. Value: %s', nome)
raise InvalidValueError(None, 'nome', nome)
# Valid protegida value
protegida = interface_map.get('protegida')
if not is_valid_boolean_param(protegida):
self.log.error(u'Parameter protegida is invalid. Value: %s',
protegida)
raise InvalidValueError(None, 'protegida', protegida)
else:
protegida = convert_string_or_int_to_boolean(protegida)
# Valid descricao value
descricao = interface_map.get('descricao')
if descricao is not None:
if not is_valid_string_minsize(
descricao, 3) or not is_valid_string_maxsize(
descricao, 200):
self.log.error(
u'Parameter descricao is invalid. Value: %s',
descricao)
raise InvalidValueError(None, 'descricao', descricao)
# Valid "id_ligacao_front" value
id_ligacao_front = interface_map.get('id_ligacao_front')
if id_ligacao_front is not None:
if not is_valid_int_greater_zero_param(id_ligacao_front):
self.log.error(
u'The id_ligacao_front parameter is not a valid value: %s.',
id_ligacao_front)
raise InvalidValueError(None, 'id_ligacao_front',
id_ligacao_front)
else:
id_ligacao_front = int(id_ligacao_front)
ligacao_front = Interface(id=id_ligacao_front)
else:
ligacao_front = None
# Valid "id_ligacao_back" value
id_ligacao_back = interface_map.get('id_ligacao_back')
if id_ligacao_back is not None:
if not is_valid_int_greater_zero_param(id_ligacao_back):
self.log.error(
u'The id_ligacao_back parameter is not a valid value: %s.',
id_ligacao_back)
raise InvalidValueError(None, 'id_ligacao_back',
id_ligacao_back)
else:
id_ligacao_back = int(id_ligacao_back)
ligacao_back = Interface(id=id_ligacao_back)
else:
ligacao_back = None
tipo_interface = interface_map.get('tipo')
if tipo_interface is None:
tipo_interface = 'Access'
tipo_interface = TipoInterface.get_by_name(tipo_interface)
vlan = interface_map.get('vlan')
# Cria a interface conforme dados recebidos no XML
interface = Interface(interface=nome,
protegida=protegida,
descricao=descricao,
ligacao_front=ligacao_front,
ligacao_back=ligacao_back,
equipamento=Equipamento(id=id_equipamento),
tipo=tipo_interface,
vlan_nativa=vlan)
interface.create(user)
networkapi_map = dict()
interface_map = dict()
interface_map['id'] = interface.id
networkapi_map['interface'] = interface_map
return self.response(dumps_networkapi(networkapi_map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def handle_delete(self, request, user, *args, **kwargs):
"""Treat DELETE requests to remove the relationship between IPv6 and equipment.
URL: ipv6/<id_ipv6>/equipment/<id_equip>/remove/
"""
from networkapi.ip.models import Ipv6, Ipv6Equipament, IpNotFoundError, IpEquipmentNotFoundError, IpEquipamentoDuplicatedError, IpError, IpCantBeRemovedFromVip, IpEquipCantDissociateFromVip, \
IpCantRemoveFromServerPool
from networkapi.equipamento.models import Equipamento, EquipamentoNotFoundError, EquipamentoError
self.log.info('Remove an IPv6 to a equipament.')
try:
ipv6_id = kwargs.get('id_ipv6')
equip_id = kwargs.get('id_equip')
# Valid Ipv6 ID
if not is_valid_int_greater_zero_param(ipv6_id):
self.log.error(
u'The id_ipv6 parameter is not a valid value: %s.',
ipv6_id)
raise InvalidValueError(None, 'id_ipv6', ipv6_id)
# Valid Ipv6 ID
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'The id_equip parameter is not a valid value: %s.',
equip_id)
raise InvalidValueError(None, 'id_equip', equip_id)
# Find Equipament by ID to check if it exist
Equipamento().get_by_pk(equip_id)
# Find IPv6 by ID to check if it exist
Ipv6().get_by_pk(ipv6_id)
with distributedlock(LOCK_IPV6 % ipv6_id):
# User permission
if not has_perm(user, AdminPermission.IPS,
AdminPermission.WRITE_OPERATION, None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.'
)
raise UserNotAuthorizedError(None)
ip = Ipv6().get_by_pk(ipv6_id)
equipament = Equipamento().get_by_pk(equip_id)
# Delete vlan's cache
destroy_cache_function([ip.networkipv6.vlan_id])
# delete equipment's cache
destroy_cache_function([equip_id], True)
# Remove Ipv6Equipament
ipv6_equipament = Ipv6Equipament()
server_pool_member_list = ServerPoolMember.objects.filter(
ipv6=ip)
if server_pool_member_list.count() != 0:
# IP associated with Server Pool
server_pool_name_list = set()
for member in server_pool_member_list:
item = '{}: {}'.format(member.server_pool.id,
member.server_pool.identifier)
server_pool_name_list.add(item)
server_pool_name_list = list(server_pool_name_list)
server_pool_identifiers = ', '.join(server_pool_name_list)
raise IpCantRemoveFromServerPool(
{
'ip': mount_ipv6_string(ip),
'equip_name': equipament.nome,
'server_pool_identifiers': server_pool_identifiers
},
'Ipv6 não pode ser disassociado do equipamento %s porque ele está sendo utilizando nos Server Pools (id:identifier) %s'
% (equipament.nome, server_pool_identifiers))
ipv6_equipament.remove(user, ipv6_id, equip_id)
return self.response(dumps_networkapi({}))
except IpCantRemoveFromServerPool, e:
return self.response_error(385, e.cause.get('ip'),
e.cause.get('equip_name'),
e.cause.get('server_pool_identifiers'))
