def available_channel_number(channel_name, interface_ids):
log.info("available channel")
interface_obj = Interface()
for interface_id in interface_ids:
interface = interface_obj.get_by_pk(interface_id)
if not interface:
raise Exception("Do not exist interface with id: %s" %
interface_id)
equipment_id = interface.equipamento.id
if not interface.ligacao_front:
raise Exception("Interface is not connected.")
front_equipment_id = interface.ligacao_front.equipamento.id
if Interface.objects.filter(equipamento=equipment_id,
channel__nome=channel_name):
raise Exception("Channel name already exist on the equipment: %s" %
channel_name)
if Interface.objects.filter(equipamento=front_equipment_id,
channel__nome=channel_name):
raise Exception("Channel name already exist on the equipment: %s" %
channel_name)
def verificar_nome_channel(nome, interfaces):
log.info("verificar_nome_channel")
interface = Interface()
channels = PortChannel.objects.filter(nome=nome)
channels_id = []
for ch in channels:
channels_id.append(int(ch.id))
if channels_id:
for var in interfaces:
if not var == '' and var is not None:
interface_id = int(var)
interface_id = interface.get_by_pk(interface_id)
equip_id = interface_id.equipamento.id
equip_interfaces = interface.search(equip_id)
for i in equip_interfaces:
try:
sw = i.get_switch_and_router_interface_from_host_interface(
i.protegida)
except:
sw = None
pass
if sw is not None:
if sw.channel is not None:
if sw.channel.id in channels_id:
raise exceptions.InterfaceException(
u'O nome do port channel ja foi '
'utilizado no equipamento')
def create_interface(interface):
try:
interface_obj = Interface()
interface_obj.create_v3(interface)
except models.InterfaceError, e:
raise ValidationAPIException(e.message)
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_get(self, request, user, *args, **kwargs):
try:
self.log.info("INTERFACE")
# 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
equip_id = kwargs.get('id_equipamento')
interface = Interface()
equip_interface = interface.search(equip_id)
interface_list = []
for var in equip_interface:
try:
interface_list.append(
get_new_interface_map(
var.
get_switch_and_router_interface_from_host_interface(
None)))
except:
pass
if len(interface_list) == 0:
raise InterfaceNotFoundError(
None, 'Erro: O servidor deve estar conectado aos uplinks')
return self.response(dumps_networkapi({'map': interface_list}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
def remove_link(interfaces):
interface_list = list()
for i in interfaces:
try:
interface_obj = Interface.objects.get(id=int(i))
interface_list.append(interface_obj)
except ObjectDoesNotExistException, e:
raise ObjectDoesNotExistException(e.detail)
except Exception, e:
raise NetworkAPIException(str(e))
try:
link = Interface()
link.disconnecting_interfaces(interface_list)
except models.InterfaceError, e:
raise ValidationAPIException(e.message)
except ObjectDoesNotExistException, e:
raise ObjectDoesNotExistException(e.detail)
except InvalidValueError, e:
raise ValidationAPIException(e)
except ValidationAPIException, e:
raise ValidationAPIException(e.detail)
except Exception, e:
raise NetworkAPIException(str(e))
def link_interface(interfaces):
def handle_put(self, request, user, *args, **kwargs):
"""Treat requests POST to add Rack.
URL: channel/editar/
"""
try:
self.log.info('Editar Channel')
# 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.')
channel_map = networkapi_map.get('channel')
if channel_map is None:
return self.response_error(3, u'There is no value to the channel tag of XML request.')
# Get XML data
id_channel = channel_map.get('id_channel')
nome = channel_map.get('nome')
if not is_valid_int_greater_zero_param(nome):
raise InvalidValueError(
None, 'Numero do Channel', 'Deve ser um numero inteiro.')
lacp = channel_map.get('lacp')
int_type = channel_map.get('int_type')
vlan_nativa = channel_map.get('vlan')
envs_vlans = channel_map.get('envs')
ids_interface = channel_map.get('ids_interface')
if ids_interface is None:
raise InterfaceError('Nenhuma interface selecionada')
if type(ids_interface) == list:
interfaces_list = ids_interface
else:
interfaces_list = str(ids_interface).split('-')
port_channel = PortChannel()
interface = Interface()
amb = Ambiente()
api_interface_facade.verificar_vlan_nativa(vlan_nativa)
# verifica se o nome do port channel já existe no equipamento
channel = port_channel.get_by_pk(int(id_channel))
if not nome == channel.nome:
api_interface_facade.verificar_nome_channel(
nome, interfaces_list)
# buscar interfaces do channel
interfaces = Interface.objects.all().filter(channel__id=id_channel)
ids_list = []
for i in interfaces:
ids_list.append(i.id)
ids_list = [int(y) for y in ids_list]
if type(ids_interface) is list:
ids_interface = [int(x) for x in ids_interface]
desassociar = set(ids_list) - set(ids_interface)
for item in desassociar:
item = interface.get_by_pk(int(item))
item.channel = None
item.save()
else:
if ids_interface is not None:
ids_interface = int(ids_interface)
if ids_interface is not None:
for item in ids_list:
item = interface.get_by_pk(int(item))
item.channel = None
item.save()
else:
for item in ids_list:
if not item == ids_interface:
item = interface.get_by_pk(int(item))
item.channel = None
item.save()
# update channel
channel.nome = str(nome)
channel.lacp = convert_string_or_int_to_boolean(lacp)
channel.save()
int_type = TipoInterface.get_by_name(str(int_type))
# update interfaces
if type(ids_interface) is not list:
i = ids_interface
ids_interface = []
ids_interface.append(i)
for var in ids_interface:
alterar_interface(var, interface, channel,
int_type, vlan_nativa, user, envs_vlans, amb)
interface = Interface()
server_obj = Interface()
interface_sw = interface.get_by_pk(int(var))
interface_server = server_obj.get_by_pk(
interface_sw.ligacao_front.id)
try:
front = interface_server.ligacao_front.id
except:
front = None
pass
try:
back = interface_server.ligacao_back.id
except:
back = None
pass
server_obj.update(user,
interface_server.id,
interface=interface_server.interface,
protegida=interface_server.protegida,
descricao=interface_server.descricao,
ligacao_front_id=front,
ligacao_back_id=back,
tipo=int_type,
vlan_nativa=int(vlan_nativa))
port_channel_map = dict()
port_channel_map['port_channel'] = port_channel
return self.response(dumps_networkapi({'port_channel': port_channel_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 add Rack.
URL: channel/inserir/
"""
try:
self.log.info('Inserir novo Channel')
# 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.')
channel_map = networkapi_map.get('channel')
if channel_map is None:
return self.response_error(3, u'There is no value to the channel tag of XML request.')
# Get XML data
interfaces = channel_map.get('interfaces')
nome = channel_map.get('nome')
lacp = channel_map.get('lacp')
int_type = channel_map.get('int_type')
vlan_nativa = channel_map.get('vlan')
envs_vlans = channel_map.get('envs')
port_channel = PortChannel()
interface = Interface()
amb = Ambiente()
cont = []
api_interface_facade.verificar_vlan_nativa(vlan_nativa)
# verifica se o nome do port channel já existe no equipamento
interfaces = str(interfaces).split('-')
api_interface_facade.verificar_nome_channel(nome, interfaces)
# cria o port channel
port_channel.nome = str(nome)
port_channel.lacp = convert_string_or_int_to_boolean(lacp)
port_channel.create(user)
int_type = TipoInterface.get_by_name(str(int_type))
for var in interfaces:
if not var == '' and not var is None:
interf = interface.get_by_pk(int(var))
try:
sw_router = interf.get_switch_and_router_interface_from_host_interface(
interf.protegida)
except:
raise InterfaceError('Interface não conectada')
if sw_router.channel is not None:
raise InterfaceError(
'Interface %s já está em um Channel' % sw_router.interface)
if cont is []:
cont.append(int(sw_router.equipamento.id))
elif not sw_router.equipamento.id in cont:
cont.append(int(sw_router.equipamento.id))
if len(cont) > 2:
raise InterfaceError(
'Mais de dois equipamentos foram selecionados')
if sw_router.ligacao_front is not None:
ligacao_front_id = sw_router.ligacao_front.id
else:
ligacao_front_id = None
if sw_router.ligacao_back is not None:
ligacao_back_id = sw_router.ligacao_back.id
else:
ligacao_back_id = None
Interface.update(user,
sw_router.id,
interface=sw_router.interface,
protegida=sw_router.protegida,
descricao=sw_router.descricao,
ligacao_front_id=ligacao_front_id,
ligacao_back_id=ligacao_back_id,
tipo=int_type,
vlan_nativa=vlan_nativa,
channel=port_channel)
if 'trunk' in int_type.tipo:
interface_list = EnvironmentInterface.objects.all().filter(interface=sw_router.id)
for int_env in interface_list:
int_env.delete()
if type(envs_vlans) is not list:
d = envs_vlans
envs_vlans = []
envs_vlans.append(d)
for i in envs_vlans:
amb = amb.get_by_pk(int(i.get('env')))
amb_int = EnvironmentInterface()
amb_int.interface = sw_router
amb_int.ambiente = amb
try:
range_vlans = i.get('vlans')
except:
range_vlans = None
pass
if range_vlans:
api_interface_facade.verificar_vlan_range(
amb, range_vlans)
amb_int.vlans = range_vlans
amb_int.create(user)
port_channel_map = dict()
port_channel_map['port_channel'] = port_channel
return self.response(dumps_networkapi({'port_channel': port_channel_map}))
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 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_get(self, request, user, *args, **kwargs):
"""Handles GET requests to find all Racks
URLs: /rack/find/
"""
self.log.info('Get Rack by equipment id')
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
equip_id = kwargs.get('equip_id')
equip_id = int(equip_id)
rack_map = []
interface = Interface()
try:
racks = Rack.objects.filter(id_sw1__id=equip_id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
try:
racks = Rack.objects.filter(id_sw2__id=equip_id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
try:
racks = Rack.objects.filter(id_ilo__id=equip_id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
try:
interfaces = interface.search(equip_id)
for interf in interfaces:
sw_router = interf.get_switch_and_router_interface_from_host_interface(
interf.protegida)
try:
racks = Rack.objects.filter(
id_sw1__id=sw_router.equipamento.id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
try:
racks = Rack.objects.filter(
id_sw2__id=sw_router.equipamento.id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
try:
racks = Rack.objects.filter(
id_ilo__id=sw_router.equipamento.id)
for cont in racks:
rack_map.append(model_to_dict(cont))
return self.response(dumps_networkapi({'rack': rack_map}))
except:
pass
except:
pass
return self.response(dumps_networkapi({'rack': rack_map}))
except UserNotAuthorizedError:
return self.not_authorized()
except RackError:
return self.response_error(1)
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
