示例#1
0
def dic_fe_prod(rack):

    CIDRFEipv4 = {}
    CIDRFEipv4[rack] = []
    CIDRFEipv6 = {}
    CIDRFEipv6[rack] = []

    subnetsRackFEipv4 = {}
    subnetsRackFEipv4[rack] = []
    subnetsRackFEipv6 = {}
    subnetsRackFEipv6[rack] = []

    podsFEipv4 = {}
    podsFEipv4[rack] = []
    podsFEipv6 = {}
    podsFEipv6[rack] = []

    redes = dict()
    ranges = dict()
    ipv6 = dict()

    try:
        # CIDR sala 01 => 172.20.0.0/14
        # Sumário do rack => 172.20.0.0/21
        CIDRFEipv4[0] = IPNetwork(get_variable('cidr_fe_v4'))
        # CIDRFE[1] = IPNetwork('172.20.1.0/14')
        CIDRFEipv6[0] = IPNetwork(get_variable('cidr_fe_v6'))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável VLAN_MNGT<BE,FE,BO,CA,FILER> ou CIDR<FEv4,FEv6>.'
        )
示例#2
0
def generate_delete_file(user, equip_id, interface_list, channel):
    try:
        INTERFACE_CONFIG_FILES_PATH = get_variable("interface_config_files_path")
        TEMPLATE_REMOVE_CHANNEL = get_variable("template_remove_channel")
        TEMPLATE_REMOVE_INTERFACE = get_variable("template_remove_interface")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável INTERFACE_CONFIG_TEMPLATE_PATH, TEMPLATE_REMOVE_CHANNEL ou TEMPLATE_REMOVE_INTERFACE.")

    key_dict = dict()
    config_to_be_saved = ""
    request_id = getattr(local, 'request_id', NO_REQUEST_ID)
    filename_out = "equip_"+str(equip_id) +"_channel_"+str(channel.id)+"_remove_"+str(request_id)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH+filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_FILES_PATH+filename_out

    key_dict['PORTCHANNEL_NAME'] = channel.nome

    for i in interface_list:
        key_dict['INTERFACE_NAME'] = i.interface
        try:
            interface_template_file = _load_template_file(int(equip_id),TEMPLATE_REMOVE_INTERFACE)
            config_to_be_saved += interface_template_file.render(Context(key_dict))
        except exceptions.InterfaceTemplateException, e:
            log.error(e)
            raise exceptions.InterfaceTemplateException()
        except KeyError, exception:
            log.error("Erro: %s " % exception)
            raise exceptions.InvalidKeyException(exception)
def dic_fe_prod(rack):

    CIDRFEipv4 = {}
    CIDRFEipv4[rack] = []
    CIDRFEipv6 = {}
    CIDRFEipv6[rack] = []

    subnetsRackFEipv4 = {}
    subnetsRackFEipv4[rack] = []
    subnetsRackFEipv6 = {}
    subnetsRackFEipv6[rack] = []

    redes=dict()
    ranges=dict()
    ipv6=dict()

    try:
        #CIDR sala 01 => 172.20.0.0/14
        #Sumário do rack => 172.20.0.0/21
        CIDRFEipv4[0] = IPNetwork(get_variable("cidr_fe_v4"))
        #CIDRFE[1] = IPNetwork('172.20.1.0/14')
        CIDRFEipv6[0] = IPNetwork(get_variable("cidr_fe_v6"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável VLAN_MNGT<BE,FE,BO,CA,FILER> ou CIDR<FEv4,FEv6>.")
示例#4
0
def _generate_config_file(interfaces_list):
    log.info("_generate_config_file")

    try:
        INTERFACE_CONFIG_TOAPPLY_REL_PATH = get_variable(
            'interface_config_toapply_rel_path')
        INTERFACE_CONFIG_FILES_PATH = get_variable(
            'interface_config_files_path')
        TEMPLATE_TYPE_INT = get_variable('template_type_int')
        TEMPLATE_TYPE_CHANNEL = get_variable('template_type_channel')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável INTERFACE_CONFIG'
            '<TOAPPLY,TEMPLATE,FILES>_PATH.')

    # check if all interfaces are configuring same equipment
    # raises error if not
    equipment_interfaces = dict()
    equipment_interfaces[interfaces_list[0].equipamento.nome] = 1
    for interface in interfaces_list:
        if interface.equipamento.nome not in equipment_interfaces:
            log.error('Error trying to configure multiple interfaces in '
                      'different equipments in same call.')
            raise exceptions.InvalidIdInterfaceException

    config_to_be_saved = ''
    equipment_id = interfaces_list[0].equipamento.id

    request_id = getattr(local, 'request_id', NO_REQUEST_ID)
    extension = '.py' if interfaces_list[
        0].equipamento.modelo.marca.nome == "HP" else ''
    filename_out = 'int-d_' + str(
        interfaces_list[0].id) + '_config_' + str(request_id) + extension
    log.debug(filename_out)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH + filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_TOAPPLY_REL_PATH + filename_out

    int_template_file = _load_template_file(equipment_id, TEMPLATE_TYPE_INT)
    channels_configured = {}

    for interface in interfaces_list:
        key_dict = _generate_dict(interface)

        # If Interface is in channel, render the template for channel,
        # only once for each channel
        try:
            if interface.channel is not None:
                if interface.channel.id is not None and \
                        interface.channel.id not in channels_configured.keys():
                    channel_template_file = _load_template_file(
                        equipment_id, TEMPLATE_TYPE_CHANNEL)
                    config_to_be_saved += channel_template_file.render(
                        Context(key_dict))
                    channels_configured[interface.channel.id] = 1

            # Render the template for interface
            config_to_be_saved += int_template_file.render(Context(key_dict))
        except KeyError, exception:
            log.error('Erro: %s ' % exception)
            raise exceptions.InvalidKeyException(exception)
示例#5
0
def _generate_config_file(interfaces_list):
    log.info("_generate_config_file")

    try:
        INTERFACE_CONFIG_TOAPPLY_REL_PATH = get_variable(
            'interface_config_toapply_rel_path')
        INTERFACE_CONFIG_FILES_PATH = get_variable(
            'interface_config_files_path')
        TEMPLATE_TYPE_INT = get_variable('template_type_int')
        TEMPLATE_TYPE_CHANNEL = get_variable('template_type_channel')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável INTERFACE_CONFIG'
            '<TOAPPLY,TEMPLATE,FILES>_PATH.')

    # check if all interfaces are configuring same equipment
    # raises error if not
    equipment_interfaces = dict()
    equipment_interfaces[interfaces_list[0].equipamento.nome] = 1
    for interface in interfaces_list:
        if interface.equipamento.nome not in equipment_interfaces:
            log.error(
                'Error trying to configure multiple interfaces in '
                'different equipments in same call.')
            raise exceptions.InvalidIdInterfaceException

    config_to_be_saved = ''
    equipment_id = interfaces_list[0].equipamento.id

    request_id = getattr(local, 'request_id', NO_REQUEST_ID)
    extension = '.py' if interfaces_list[0].equipamento.modelo.marca.nome == "HP" else ''
    filename_out = 'int-d_' + str(interfaces_list[0].id) + '_config_' + str(request_id) + extension
    log.debug(filename_out)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH + filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_TOAPPLY_REL_PATH + filename_out

    int_template_file = _load_template_file(equipment_id, TEMPLATE_TYPE_INT)
    channels_configured = {}

    for interface in interfaces_list:
        key_dict = _generate_dict(interface)

        # If Interface is in channel, render the template for channel,
        # only once for each channel
        try:
            if interface.channel is not None:
                if interface.channel.id is not None and \
                        interface.channel.id not in channels_configured.keys():
                    channel_template_file = _load_template_file(
                        equipment_id, TEMPLATE_TYPE_CHANNEL)
                    config_to_be_saved += channel_template_file.render(
                        Context(key_dict))
                    channels_configured[interface.channel.id] = 1

            # Render the template for interface
            config_to_be_saved += int_template_file.render(Context(key_dict))
        except KeyError, exception:
            log.error('Erro: %s ' % exception)
            raise exceptions.InvalidKeyException(exception)
示例#6
0
    def post(self, *args, **kwargs):
        try:
            log.info('RACK deploy.')

            rack_id = kwargs.get('rack_id')
            rack = facade.get_by_pk(rack_id)

            try:
                PATH_TO_ADD_CONFIG = get_variable('path_to_add_config')
                REL_PATH_TO_ADD_CONFIG = get_variable('rel_path_to_add_config')
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável PATH_TO_ADD_CONFIG ou "
                                                                   "REL_PATH_TO_ADD_CONFIG.")

            path_config = PATH_TO_ADD_CONFIG + '*' + rack.nome + '*'
            arquivos = glob.glob(path_config)

            # Get all files and search for equipments of the rack
            for var in arquivos:
                filename_equipments = var.split('/')[-1]
                rel_filename = REL_PATH_TO_ADD_CONFIG + filename_equipments
                log.debug("rel_filename: %s" % rel_filename)
                # Check if file is config relative to this rack
                if rack.nome in filename_equipments:
                    # Apply config only in spines. Leaves already have all necessary config in startup
                    if "ADD" in filename_equipments:
                        # Check if equipment in under maintenance. If so, does not aplly on it
                        equipment_name = filename_equipments.split('-ADD-')[0]
                        log.debug("equipment_name: %s" % equipment_name)
                        try:
                            equip = Equipamento.get_by_name(equipment_name)
                            if not equip.maintenance:
                                lockvar = LOCK_EQUIPMENT_DEPLOY_CONFIG_USERSCRIPT % (equip.id)
                                output = deploy_facade.deploy_config_in_equipment_synchronous(rel_filename, equip, lockvar)

                                log.debug("equipment output: %s" % (output))
                        except Exception as e:
                            log.exception(e)
                            raise exceptions.RackAplError(e)
            # SEPARAR AQUI!

            datas = dict()
            success_map = dict()

            success_map['rack_conf'] = True
            datas['sucesso'] = success_map

            return Response(datas, status=status.HTTP_201_CREATED)

        except exceptions.RackNumberNotFoundError as e:
            log.exception(e)
            raise exceptions.NetworkAPIException(e)
        except var_exceptions.VariableDoesNotExistException as e:
            log.error(e)
            raise api_exceptions.NetworkAPIException(
                'Erro buscando a variável PATH_TO_ADD_CONFIG ou REL_PATH_TO_ADD_CONFIG. Erro: %s' % e)
        except Exception as e:
            log.exception(e)
            raise api_exceptions.NetworkAPIException(e)
示例#7
0
def dic_pods(rack):

    subnetsRackBEipv4 = {}
    subnetsRackBEipv4[rack] = []

    PODSBEipv4 = {}
    redesPODSBEipv4 = {}
    PODSBEFEipv4 = {}
    redesPODSBEFEipv4 = {}
    PODSBEBOipv4 = {}
    redesPODSBEBOipv4 = {}
    PODSBECAipv4 = {}
    redesPODSBECAipv4 = {}

    PODSBEipv4[rack] = []
    redesPODSBEipv4[rack] = []
    PODSBEFEipv4[rack] = []
    redesPODSBEFEipv4[rack] = []
    PODSBEBOipv4[rack] = []
    redesPODSBEBOipv4[rack] = []
    PODSBECAipv4[rack] = []
    redesPODSBECAipv4[rack] = []

    PODSBEipv6 = {}
    redesPODSBEipv6 = {}
    PODSBEFEipv6 = {}
    redesPODSBEFEipv6 = {}
    PODSBEBOipv6 = {}
    redesPODSBEBOipv6 = {}
    PODSBECAipv6 = {}
    redesPODSBECAipv6 = {}
    subnetsRackBEipv6 = {}

    PODSBEipv6[rack] = []
    redesPODSBEipv6[rack] = []
    PODSBEFEipv6[rack] = []
    redesPODSBEFEipv6[rack] = []
    PODSBEBOipv6[rack] = []
    redesPODSBEBOipv6[rack] = []
    PODSBECAipv6[rack] = []
    redesPODSBECAipv6[rack] = []
    subnetsRackBEipv6[rack] = []

    try:
        # CIDR sala 01 => 10.128.0.0/12
        CIDRBEipv4 = IPNetwork(get_variable('cidr_be_v4'))
        CIDRBEipv6 = IPNetwork(get_variable('cidr_be_v6'))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável CIDR<BEv4,BEv6>.')
def dic_pods(rack):

    subnetsRackBEipv4 = {}
    subnetsRackBEipv4[rack] = []

    PODSBEipv4 = {}
    redesPODSBEipv4 = {}
    PODSBEFEipv4 = {}
    redesPODSBEFEipv4 = {}
    PODSBEBOipv4 = {}
    redesPODSBEBOipv4 = {}
    PODSBECAipv4 = {}
    redesPODSBECAipv4 = {}

    PODSBEipv4[rack]=[]
    redesPODSBEipv4[rack]=[]
    PODSBEFEipv4[rack]=[]
    redesPODSBEFEipv4[rack]=[]
    PODSBEBOipv4[rack]=[]
    redesPODSBEBOipv4[rack]=[]
    PODSBECAipv4[rack]=[]
    redesPODSBECAipv4[rack]=[]

    PODSBEipv6 = {}
    redesPODSBEipv6 = {}
    PODSBEFEipv6 = {}
    redesPODSBEFEipv6 = {}
    PODSBEBOipv6 = {}
    redesPODSBEBOipv6 = {}
    PODSBECAipv6 = {}
    redesPODSBECAipv6 = {}
    subnetsRackBEipv6 = {}

    PODSBEipv6[rack]=[]
    redesPODSBEipv6[rack]=[]
    PODSBEFEipv6[rack]=[]
    redesPODSBEFEipv6[rack]=[]
    PODSBEBOipv6[rack]=[]
    redesPODSBEBOipv6[rack]=[]
    PODSBECAipv6[rack]=[]
    redesPODSBECAipv6[rack]=[]
    subnetsRackBEipv6[rack]=[]

    try:
        #CIDR sala 01 => 10.128.0.0/12
        CIDRBEipv4 = IPNetwork(get_variable("cidr_be_v4"))
        CIDRBEipv6 = IPNetwork(get_variable("cidr_be_v6"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável CIDR<BEv4,BEv6>.")
def _generate_config_file(interfaces_list):

    try:
        INTERFACE_CONFIG_TOAPPLY_REL_PATH = get_variable("interface_config_toapply_rel_path")
        INTERFACE_CONFIG_FILES_PATH = get_variable("interface_config_files_path")
        TEMPLATE_TYPE_INT = get_variable("template_type_int")
        TEMPLATE_TYPE_CHANNEL = get_variable("template_type_channel")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável INTERFACE_CONFIG<TOAPPLY,TEMPLATE,FILES>_PATH."
        )

    # check if all interfaces are configuring same equipment
    # raises error if not
    equipment_interfaces = dict()
    equipment_interfaces[interfaces_list[0].equipamento.nome] = 1
    for interface in interfaces_list:
        if interface.equipamento.nome not in equipment_interfaces:
            log.error("Error trying to configure multiple interfaces in different equipments in same call.")
            raise exceptions.InvalidIdInterfaceException

    config_to_be_saved = ""
    equipment_id = interfaces_list[0].equipamento.id

    request_id = getattr(local, "request_id", NO_REQUEST_ID)
    filename_out = "int-d_" + str(interfaces_list[0].id) + "_config_" + str(request_id)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH + filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_TOAPPLY_REL_PATH + filename_out

    int_template_file = _load_template_file(equipment_id, TEMPLATE_TYPE_INT)
    channels_configured = {}

    for interface in interfaces_list:
        key_dict = _generate_dict(interface)

        # If Interface is in channel, render the template for channel, only once
        # for each channel
        try:
            if interface.channel is not None:
                if interface.channel.id is not None and interface.channel.id not in channels_configured.keys():
                    channel_template_file = _load_template_file(equipment_id, TEMPLATE_TYPE_CHANNEL)
                    config_to_be_saved += channel_template_file.render(Context(key_dict))
                    channels_configured[interface.channel.id] = 1

            # Render the template for interface
            config_to_be_saved += int_template_file.render(Context(key_dict))
        except KeyError, exception:
            log.error("Erro: %s " % exception)
            raise exceptions.InvalidKeyException(exception)
def ambiente_prod_fe(user, rack, environment_list):

    redes, ranges, ipv6 = dic_fe_prod(rack.numero)

    ambientes= dict()
    ambientes['LOG']="PRODUCAO"
    ambientes['L3']= rack.nome
    ambientes['DC']="FE"

    redes['TIPO']= "Rede invalida equipamentos"
    ipv6['TIPO']= "Rede invalida equipamentos"

    acl_path = 'FECLOUD'

    #criar ambiente
    env = criar_ambiente(user, ambientes, ranges, acl_path, "Servidores", "FEVrf")
    environment_list.append(env)

    #configuracao dos ambientes
    redes['VERSION']="ipv4"
    config_ambiente(user, redes, ambientes)

    ipv6['VERSION']="ipv6"
    config_ambiente(user, ipv6, ambientes)

    vlans=dict()
    try:
        vlans['VLAN_NUM'] = int(get_variable("num_vlan_acl_fe"))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável  NUM_VLAN_ACL_FE")

    vlans['VLAN_NAME'] = "ACL_"+ambientes.get('DC')+"_"+ambientes.get('L3')
    criar_vlan(user, vlans, ambientes, 1)

    return environment_list
def aplicar(rack):

    try:
        PATH_TO_CONFIG = get_variable("path_to_config")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável PATH_TO_CONFIG.")

    path_config = PATH_TO_CONFIG +'*'+rack.nome+'*'
    arquivos = glob.glob(path_config)
    for var in arquivos: 
        name_equipaments = var.split('/')[-1][:-4]      
        #Check if file is config relative to this rack
        for nome in name_equipaments:
            #Check if file is config relative to this rack
            if rack.nome in nome:
                #Apply config only in spines. Leaves already have all necessary config in startup
                if "DEL" in nome:
                    #Check if equipment in under maintenance. If so, does not aplly on it
                    try:
                        equip = Equipamento.get_by_name(nome)
                        if not equip.maintenance:
                            (erro, result) = commands.getstatusoutput("/usr/bin/backuper -T acl -b %s -e -i %s -w 300" % (var, nome))
                            if erro:
                                raise RackAplError(None, None, "Falha ao aplicar as configuracoes: %s" %(result))
                    except RackAplError, e:
                        raise e
                    except:
                        #Error equipment not found, do nothing
                        pass
示例#12
0
def aplicar(rack):

    try:
        PATH_TO_CONFIG = get_variable("path_to_config")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável PATH_TO_CONFIG.")

    path_config = PATH_TO_CONFIG + '*' + rack.nome + '*'
    arquivos = glob.glob(path_config)
    for var in arquivos:
        name_equipaments = var.split('/')[-1][:-4]
        #Check if file is config relative to this rack
        for nome in name_equipaments:
            #Check if file is config relative to this rack
            if rack.nome in nome:
                #Apply config only in spines. Leaves already have all necessary config in startup
                if "DEL" in nome:
                    #Check if equipment in under maintenance. If so, does not aplly on it
                    try:
                        equip = Equipamento.get_by_name(nome)
                        if not equip.maintenance:
                            (erro, result) = commands.getstatusoutput(
                                "/usr/bin/backuper -T acl -b %s -e -i %s -w 300"
                                % (var, nome))
                            if erro:
                                raise RackAplError(
                                    None, None,
                                    "Falha ao aplicar as configuracoes: %s" %
                                    (result))
                    except RackAplError, e:
                        raise e
                    except:
                        #Error equipment not found, do nothing
                        pass
def _load_template_file(equipment_id, template_type):

    try:
        INTERFACE_CONFIG_TEMPLATE_PATH = get_variable("interface_config_template_path")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável INTERFACE_CONFIG<TOAPPLY,TEMPLATE,FILES>_PATH."
        )

    try:
        equipment_template = (EquipamentoRoteiro.search(None, equipment_id, template_type)).uniqueResult()
    except:
        log.error("Template type %s not found. Equip: %s" % (template_type, equipment_id))
        raise exceptions.InterfaceTemplateException()

    filename_in = INTERFACE_CONFIG_TEMPLATE_PATH + equipment_template.roteiro.roteiro

    # Read contents from file
    try:
        file_handle = open(filename_in, "r")
        template_file = Template(file_handle.read())
        file_handle.close()
    except IOError, e:
        log.error("Error opening template file for read: %s. Equip: %s" % (filename_in, equipment_id))
        raise e
示例#14
0
def _load_template_file(equipment_id, template_type):
    log.info("_load_template_file")

    try:
        INTERFACE_CONFIG_TEMPLATE_PATH = get_variable(
            'interface_config_template_path')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável INTERFACE_CONFIG'
            '<TOAPPLY,TEMPLATE,FILES>_PATH.')

    try:
        equipment_template = (EquipamentoRoteiro.search(
            None, equipment_id, template_type)).uniqueResult()
    except:
        log.error('Template type %s not found. Equip: %s' %
                  (template_type, equipment_id))
        raise exceptions.InterfaceTemplateException()

    filename_in = INTERFACE_CONFIG_TEMPLATE_PATH + \
        equipment_template.roteiro.roteiro

    # Read contents from file
    try:
        file_handle = open(filename_in, 'r')
        template_file = Template(file_handle.read())
        file_handle.close()
    except IOError, e:
        log.error('Error opening template file for read: %s. Equip: %s' %
                  (filename_in, equipment_id))
        raise e
def ambiente_prod(user, rack, environment_list):

    redes, ipv6 = dic_pods(rack.numero)

    divisao_aclpaths = [['BE','BECLOUD'],['BEFE','BEFE'],['BEBORDA','BEBORDA'],['BECACHOS','BECACHOS']]

    grupol3 = rack.nome
    ambiente_logico = "PRODUCAO"

    ambientes= dict()   
    ambientes['LOG']=ambiente_logico
    ambientes['L3']= grupol3

    ranges=dict()
    hosts=dict()
    vlans=dict()

    try:
        base_vlan = int(get_variable("num_vlan_acl_be"))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável  NUM_VLAN_ACL_BE")

    hosts['TIPO']= "Rede invalida equipamentos"
    ipv6['TIPO']= "Rede invalida equipamentos"

    for item in divisao_aclpaths:
        divisaodc = item[0]
        acl_path = item[1]

        ambientes['DC']=divisaodc

        #criar ambiente
        vlan_min = divisaodc+"_VLAN_MIN"
        vlan_max = divisaodc+"_VLAN_MAX"
        ranges['MAX']= redes.get(vlan_max)
        ranges['MIN']= redes.get(vlan_min)

        env = criar_ambiente(user, ambientes, ranges, acl_path, "Servidores", "BEVrf")
        environment_list.append(env)

        #configuracao dos ambientes
        prefix = divisaodc+"_PREFIX"
        rede = divisaodc+"_REDE"

        hosts['PREFIX']= redes.get(prefix)
        hosts['REDE']= redes.get(rede)
        hosts['VERSION']="ipv4"
        config_ambiente(user, hosts, ambientes)

        ipv6['PREFIX']=ipv6.get(prefix)
        ipv6['REDE']=ipv6.get(rede)
        ipv6['VERSION']="ipv6"
        config_ambiente(user, ipv6, ambientes)

        vlans['VLAN_NUM'] = base_vlan
        base_vlan += 1
        vlans['VLAN_NAME'] = "ACL_"+divisaodc+"_"+ambientes.get('L3')
        criar_vlan(user, vlans, ambientes, 1)

    return environment_list
示例#16
0
        def inner(*args, **kwargs):
            if get_variable('mock_return', '0') == '0':
                return func(*args, **kwargs)

            def mock():
                return mock_value

            return mock()
示例#17
0
        def inner(*args, **kwargs):
            if get_variable('mock_return', '0') == '0':
                return func(*args, **kwargs)

            def mock():
                return mock_value

            return mock()
示例#18
0
    def post(self, *args, **kwargs):
        try:
            log.info('RACK deploy.')

            rack_id = kwargs.get('rack_id')
            rack = facade.get_by_pk(rack_id)

            try:
                PATH_TO_ADD_CONFIG = get_variable('path_to_add_config')
                REL_PATH_TO_ADD_CONFIG = get_variable('rel_path_to_add_config')
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException(
                    "Erro buscando a variável PATH_TO_ADD_CONFIG ou "
                    "REL_PATH_TO_ADD_CONFIG.")

            path_config = PATH_TO_ADD_CONFIG + '*' + rack.nome + '*'
            arquivos = glob.glob(path_config)

            # Get all files and search for equipments of the rack
            for var in arquivos:
                filename_equipments = var.split('/')[-1]
                rel_filename = "../../" + REL_PATH_TO_ADD_CONFIG + filename_equipments
                log.debug("rel_filename: %s" % rel_filename)
                # Check if file is config relative to this rack
                if rack.nome in filename_equipments:
                    # Apply config only in spines. Leaves already have all necessary config in startup
                    if "ADD" in filename_equipments:
                        # Check if equipment in under maintenance. If so, does not aplly on it
                        equipment_name = filename_equipments.split('-ADD-')[0]
                        log.debug("equipment_name: %s" % equipment_name)
                        try:
                            equip = Equipamento.get_by_name(equipment_name)
                            if not equip.maintenance:
                                (erro, result) = commands.getstatusoutput(
                                    "/usr/bin/backuper -T acl -b %s -e -i %s -w "
                                    "300" % (rel_filename, equipment_name))
                                log.debug("erro: %s, result: %s" %
                                          (str(erro), str(result)))
                                if erro:
                                    raise exceptions.RackAplError()
                        except exceptions.RackAplError, e:
                            raise e
                        except:
                            # Error equipment not found, do nothing
                            pass
示例#19
0
def dic_hosts_cloud(rack):

    subnetsRackBEipv4 = {}
    subnetsRackBEipv4[rack] = []
    redesHostsipv4 = {}
    redesHostsipv4[rack] = []
    redeHostsBEipv4 = {}
    redeHostsBEipv4[rack] = []
    redeHostsFEipv4 = {}
    redeHostsFEipv4[rack] = []
    redeHostsBOipv4 = {}
    redeHostsBOipv4[rack] = []
    redeHostsCAipv4 = {}
    redeHostsCAipv4[rack] = []
    redeHostsFILERipv4 = {}
    redeHostsFILERipv4[rack] = []

    subnetsRackBEipv6 = {}
    subnetsRackBEipv6[rack] = []
    redesHostsipv6 = {}
    redesHostsipv6[rack] = []
    redeHostsBEipv6 = {}
    redeHostsBEipv6[rack] = []
    redeHostsFEipv6 = {}
    redeHostsFEipv6[rack] = []
    redeHostsBOipv6 = {}
    redeHostsBOipv6[rack] = []
    redeHostsCAipv6 = {}
    redeHostsCAipv6[rack] = []
    redeHostsFILERipv6 = {}
    redeHostsFILERipv6[rack] = []

    hosts = dict()
    BE = dict()
    FE = dict()
    BO = dict()
    CA = dict()
    FILER = dict()
    ipv6 = dict()
    BE_ipv6 = dict()
    FE_ipv6 = dict()
    BO_ipv6 = dict()
    CA_ipv6 = dict()
    FILER_ipv6 = dict()

    try:
        # CIDR sala 01 => 10.128.0.0/12
        CIDRBEipv4 = IPNetwork(get_variable('cidr_be_v4'))
        CIDRBEipv6 = IPNetwork(get_variable('cidr_be_v6'))
        hosts['VLAN_MNGT_BE'] = int(get_variable('vlan_mngt_be'))
        hosts['VLAN_MNGT_FE'] = int(get_variable('vlan_mngt_fe'))
        hosts['VLAN_MNGT_BO'] = int(get_variable('vlan_mngt_bo'))
        hosts['VLAN_MNGT_CA'] = int(get_variable('vlan_mngt_ca'))
        hosts['VLAN_MNGT_FILER'] = int(get_variable('vlan_mngt_filer'))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável VLAN_MNGT<BE,FE,BO,CA,FILER> ou CIDR<BEv4,BEv6>.'
        )
示例#20
0
def ambiente_borda(user, rack, environment_list):

    ranges = dict()
    ranges['MAX'] = None
    ranges['MIN'] = None
    ranges_vlans = dict()

    try:
        ranges_vlans['BORDA_DSR_VLAN_MIN'] = int(
            get_variable('borda_dsr_vlan_min'))
        ranges_vlans['BORDA_DSR_VLAN_MAX'] = int(
            get_variable('borda_dsr_vlan_max'))
        ranges_vlans['BORDA_DMZ_VLAN_MIN'] = int(
            get_variable('borda_dmz_vlan_min'))
        ranges_vlans['BORDA_DMZ_VLAN_MAX'] = int(
            get_variable('borda_dmz_vlan_max'))
        ranges_vlans['BORDACACHOS_VLAN_MIN'] = int(
            get_variable('bordacachos_vlan_min'))
        ranges_vlans['BORDACACHOS_VLAN_MAX'] = int(
            get_variable('bordacachos_vlan_max'))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando as variáveis BORDA<DSR,DMZ,CACHOS>_VLAN_<MAX,MIN>.')
    try:
        base_vlan = int(get_variable('num_vlan_acl_bordadsr'))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável  NUM_VLAN_ACL_BORDADSR')

    ambientes = dict()
    vlans = dict()
    ambientes['LOG'] = 'PRODUCAO'
    ambientes['L3'] = rack.nome
    divisao_aclpaths = [['BORDA_DSR', 'BORDA-DSR', 'BordaVrf'],
                        ['BORDA_DMZ', 'BORDA-DMZ', 'BordaVrf'],
                        ['BORDACACHOS', 'BORDACACHOS', 'BordaCachosVrf']]

    for item in divisao_aclpaths:
        divisaodc = item[0]
        acl_path = item[1]
        vrf = item[2]

        vlan_min = divisaodc + '_VLAN_MIN'
        vlan_max = divisaodc + '_VLAN_MAX'
        ranges['MAX'] = ranges_vlans.get(vlan_max)
        ranges['MIN'] = ranges_vlans.get(vlan_min)

        ambientes['DC'] = divisaodc
        env = criar_ambiente(user, ambientes, ranges, acl_path, 'Servidores',
                             vrf)
        environment_list.append(env)

        vlans['VLAN_NUM'] = base_vlan
        base_vlan += 1
        vlans['VLAN_NAME'] = 'ACL_' + divisaodc + '_' + ambientes.get('L3')
        criar_vlan(user, vlans, ambientes, 1)

    return environment_list
示例#21
0
def dic_hosts_cloud(rack):

    subnetsRackBEipv4 = {}
    subnetsRackBEipv4[rack] = []
    redesHostsipv4={}
    redesHostsipv4[rack]=[]
    redeHostsBEipv4={}
    redeHostsBEipv4[rack]=[]
    redeHostsFEipv4={}
    redeHostsFEipv4[rack]=[]
    redeHostsBOipv4={}
    redeHostsBOipv4[rack]=[]
    redeHostsCAipv4={}
    redeHostsCAipv4[rack]=[]
    redeHostsFILERipv4={}
    redeHostsFILERipv4[rack]=[]

    subnetsRackBEipv6 = {}
    subnetsRackBEipv6[rack] = []
    redesHostsipv6={}
    redesHostsipv6[rack]=[]
    redeHostsBEipv6={}
    redeHostsBEipv6[rack]=[]
    redeHostsFEipv6={}
    redeHostsFEipv6[rack]=[]
    redeHostsBOipv6={}
    redeHostsBOipv6[rack]=[]
    redeHostsCAipv6={}
    redeHostsCAipv6[rack]=[]
    redeHostsFILERipv6={}
    redeHostsFILERipv6[rack]=[]

    hosts=dict()
    BE=dict()
    FE=dict()
    BO=dict()
    CA= dict()
    FILER=dict()
    ipv6=dict()
    BE_ipv6=dict()
    FE_ipv6=dict()
    BO_ipv6=dict()
    CA_ipv6= dict()
    FILER_ipv6=dict()

    try:
        #CIDR sala 01 => 10.128.0.0/12
        CIDRBEipv4 = IPNetwork(get_variable("cidr_be_v4"))
        CIDRBEipv6 = IPNetwork(get_variable("cidr_be_v6"))
        hosts['VLAN_MNGT_BE']=int(get_variable("vlan_mngt_be"))
        hosts['VLAN_MNGT_FE']=int(get_variable("vlan_mngt_fe"))
        hosts['VLAN_MNGT_BO']=int(get_variable("vlan_mngt_bo"))
        hosts['VLAN_MNGT_CA']=int(get_variable("vlan_mngt_ca"))
        hosts['VLAN_MNGT_FILER']=int(get_variable("vlan_mngt_filer"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável VLAN_MNGT<BE,FE,BO,CA,FILER> ou CIDR<BEv4,BEv6>.")
示例#22
0
    def post(self, *args, **kwargs):
        try:
            log.info('RACK deploy.')

            rack_id = kwargs.get('rack_id')
            rack = facade.get_by_pk(rack_id)

            try:
                PATH_TO_ADD_CONFIG = get_variable('path_to_add_config')
                REL_PATH_TO_ADD_CONFIG = get_variable('rel_path_to_add_config')
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável PATH_TO_ADD_CONFIG ou "
                                                                   "REL_PATH_TO_ADD_CONFIG.")

            path_config = PATH_TO_ADD_CONFIG + '*' + rack.nome + '*'
            arquivos = glob.glob(path_config)

            # Get all files and search for equipments of the rack
            for var in arquivos:
                filename_equipments = var.split('/')[-1]
                rel_filename = "../../" + REL_PATH_TO_ADD_CONFIG + filename_equipments
                log.debug("rel_filename: %s" % rel_filename)
                # Check if file is config relative to this rack
                if rack.nome in filename_equipments:
                    # Apply config only in spines. Leaves already have all necessary config in startup
                    if "ADD" in filename_equipments:
                        # Check if equipment in under maintenance. If so, does not aplly on it
                        equipment_name = filename_equipments.split('-ADD-')[0]
                        log.debug("equipment_name: %s" % equipment_name)
                        try:
                            equip = Equipamento.get_by_name(equipment_name)
                            if not equip.maintenance:
                                (erro, result) = commands.getstatusoutput("/usr/bin/backuper -T acl -b %s -e -i %s -w "
                                                                          "300" % (rel_filename, equipment_name))
                                log.debug("erro: %s, result: %s" % (str(erro), str(result)))
                                if erro:
                                    raise exceptions.RackAplError()
                        except exceptions.RackAplError, e:
                            raise e
                        except:
                            # Error equipment not found, do nothing
                            pass
示例#23
0
def dic_vlan_core(variablestochangecore, rack, name_core, name_rack):
    """
    variablestochangecore: list
    rack: Numero do Rack
    name_core: Nome do Core
    name_rack: Nome do rack
    """

    core = int(name_core.split("-")[2])

    try:
        #valor base para as vlans e portchannels
        BASE_SO = int(get_variable("base_so"))
        #rede para conectar cores aos racks
        SO_OOB_NETipv4= IPNetwork(get_variable("net_core"))
        #Vlan para cadastrar
        vlan_so_name = get_variable("vlan_so_name")
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável BASE_SO ou SO_OOB_NETipv4.")
示例#24
0
def dic_vlan_core(variablestochangecore, rack, name_core, name_rack):
    """
    variablestochangecore: list
    rack: Numero do Rack
    name_core: Nome do Core
    name_rack: Nome do rack
    """

    core = int(name_core.split("-")[2])

    try:
        #valor base para as vlans e portchannels
        BASE_SO = int(get_variable("base_so"))
        #rede para conectar cores aos racks
        SO_OOB_NETipv4= IPNetwork(get_variable("net_core"))
        #Vlan para cadastrar
        vlan_so_name = get_variable("vlan_so_name")
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável BASE_SO ou SO_OOB_NETipv4.")
示例#25
0
def _generate_dict(interface):
    log.info("_generate_dict")

    try:
        supported_string = get_variable('supported_equipment_brands')
        SUPPORTED_EQUIPMENT_BRANDS = ast.literal_eval(supported_string)
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável supported_equipment_brands.')
    except ValueError:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável supported_equipment_brands. '
            'Formato invalido. Deve ser uma string no formato de lista.')

    # Check if it is a supported equipment interface

    if interface.equipamento.modelo.marca.nome not in \
            SUPPORTED_EQUIPMENT_BRANDS:
        raise exceptions.UnsupportedEquipmentException()

    key_dict = {}
    # TODO Separate differet vendor support
    # Cisco Nexus 6001 dict
    key_dict['NATIVE_VLAN'] = interface.vlan_nativa
    key_dict['USE_MCLAG'] = 1
    key_dict['INTERFACE_NAME'] = interface.interface
    key_dict['INTERFACE_DESCRIPTION'] = str(
        interface.ligacao_front.equipamento.nome) + ' ' + str(
            interface.ligacao_front.interface)
    key_dict['INTERFACE_TYPE'] = interface.tipo.tipo
    if key_dict['INTERFACE_TYPE'] in 'trunk':
        vlan_range_results = get_vlan_range(interface)
        key_dict['VLAN_RANGE'] = vlan_range_results[0]
        key_dict['VLAN_RANGE_LIST'] = vlan_range_results[1]

    if interface.channel is not None:
        key_dict['BOOL_INTERFACE_IN_CHANNEL'] = 1
        key_dict['PORTCHANNEL_NAME'] = interface.channel.nome
        try:
            key_dict['MCLAG_IDENTIFIER'] = int(
                re.sub(r'[a-zA\-]', '', interface.channel.nome))
        except ValueError, e:
            log.error('Error: invalid channel name')
            raise e
        if interface.channel.lacp:
            key_dict['CHANNEL_LACP_MODE'] = 'active'
        else:
            key_dict['CHANNEL_LACP_MODE'] = 'on'

        # Normally used in junos plugin:
        key_dict['LACP_SYSTEM_ID_MAC'] = __generate_lacp_system_id_mac(
            interface.channel.nome)
示例#26
0
def generate_delete_file(user, equip_id, interface_list, channel):
    try:
        INTERFACE_CONFIG_TOAPPLY_REL_PATH = get_variable(
            'interface_config_toapply_rel_path')
        INTERFACE_CONFIG_FILES_PATH = get_variable(
            'interface_config_files_path')
        TEMPLATE_REMOVE_CHANNEL = get_variable('template_remove_channel')
        TEMPLATE_REMOVE_INTERFACE = get_variable('template_remove_interface')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável INTERFACE_CONFIG_TEMPLATE_PATH,'
            'TEMPLATE_REMOVE_CHANNEL ou TEMPLATE_REMOVE_INTERFACE.')

    key_dict = dict()
    config_to_be_saved = ''
    request_id = getattr(local, 'request_id', NO_REQUEST_ID)
    extension = '.py' if interface_list[
        0].equipamento.modelo.marca.nome == "HP" else ''
    filename_out = 'equip_' + str(equip_id) + '_channel_' + str(
        channel.id) + '_remove_' + str(request_id) + extension
    log.debug(filename_out)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH + filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_TOAPPLY_REL_PATH + filename_out

    key_dict['PORTCHANNEL_NAME'] = channel.nome

    for i in interface_list:
        key_dict['INTERFACE_NAME'] = i.interface
        try:
            interface_template_file = _load_template_file(
                int(equip_id), TEMPLATE_REMOVE_INTERFACE)
            config_to_be_saved += interface_template_file.render(
                Context(key_dict))
        except exceptions.InterfaceTemplateException, e:
            log.error(e)
            raise exceptions.InterfaceTemplateException()
        except KeyError, exception:
            log.error('Erro: %s ' % exception)
            raise exceptions.InvalidKeyException(exception)
示例#27
0
def generate_delete_file(user, equip_id, interface_list, channel):
    try:
        INTERFACE_CONFIG_TOAPPLY_REL_PATH = get_variable(
            'interface_config_toapply_rel_path')
        INTERFACE_CONFIG_FILES_PATH = get_variable(
            'interface_config_files_path')
        TEMPLATE_REMOVE_CHANNEL = get_variable('template_remove_channel')
        TEMPLATE_REMOVE_INTERFACE = get_variable('template_remove_interface')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável INTERFACE_CONFIG_TEMPLATE_PATH,'
            'TEMPLATE_REMOVE_CHANNEL ou TEMPLATE_REMOVE_INTERFACE.')

    key_dict = dict()
    config_to_be_saved = ''
    request_id = getattr(local, 'request_id', NO_REQUEST_ID)
    extension = '.py' if interface_list[0].equipamento.modelo.marca.nome == "HP" else ''
    filename_out = 'equip_' + str(equip_id) + '_channel_' + str(channel.id) + '_remove_' + str(request_id) + extension
    log.debug(filename_out)
    filename_to_save = INTERFACE_CONFIG_FILES_PATH + filename_out
    rel_file_to_deploy = INTERFACE_CONFIG_TOAPPLY_REL_PATH + filename_out

    key_dict['PORTCHANNEL_NAME'] = channel.nome

    for i in interface_list:
        key_dict['INTERFACE_NAME'] = i.interface
        try:
            interface_template_file = _load_template_file(
                int(equip_id), TEMPLATE_REMOVE_INTERFACE)
            config_to_be_saved += interface_template_file.render(
                Context(key_dict))
        except exceptions.InterfaceTemplateException, e:
            log.error(e)
            raise exceptions.InterfaceTemplateException()
        except KeyError, exception:
            log.error('Erro: %s ' % exception)
            raise exceptions.InvalidKeyException(exception)
示例#28
0
def get_local_tunnel_ip(equipment):

    try:
        networkv4_tunnel_id = get_variable("networkv4_tunnel_ip")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando o id da rede com o local_tunnel_ip")

    unique_ip = IpEquipamento.objects.filter(equipamento=equipment, ip__networkipv4=networkv4_tunnel_id)\
        .select_related('ip').uniqueResult()

    log.debug('equip %s' % equipment)
    log.debug('unique_ip: %s' % unique_ip.ip.ip_formated)

    return unique_ip.ip.ip_formated
示例#29
0
def _generate_dict(interface):
    log.info("_generate_dict")

    try:
        supported_string = get_variable('supported_equipment_brands')
        SUPPORTED_EQUIPMENT_BRANDS = ast.literal_eval(supported_string)
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável supported_equipment_brands.')
    except ValueError:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável supported_equipment_brands. '
            'Formato invalido. Deve ser uma string no formato de lista.')

    # Check if it is a supported equipment interface

    if interface.equipamento.modelo.marca.nome not in \
            SUPPORTED_EQUIPMENT_BRANDS:
        raise exceptions.UnsupportedEquipmentException()

    key_dict = {}
    # TODO Separate differet vendor support
    # Cisco Nexus 6001 dict
    key_dict['NATIVE_VLAN'] = interface.vlan_nativa
    key_dict['USE_MCLAG'] = 1
    key_dict['INTERFACE_NAME'] = interface.interface
    key_dict['INTERFACE_DESCRIPTION'] = str(
        interface.ligacao_front.equipamento.nome
    ) + ' ' + str(interface.ligacao_front.interface)
    key_dict['INTERFACE_TYPE'] = interface.tipo.tipo
    if key_dict['INTERFACE_TYPE'] in 'trunk':
        vlan_range_results = get_vlan_range(interface)
        key_dict['VLAN_RANGE'] = vlan_range_results[0]
        key_dict['VLAN_RANGE_LIST'] = vlan_range_results[1]

    if interface.channel is not None:
        key_dict['BOOL_INTERFACE_IN_CHANNEL'] = 1
        key_dict['PORTCHANNEL_NAME'] = interface.channel.nome
        try:
            key_dict['MCLAG_IDENTIFIER'] = int(
                re.sub(r'[a-zA\-]', '', interface.channel.nome))
        except ValueError, e:
            log.error('Error: invalid channel name')
            raise e
        if interface.channel.lacp:
            key_dict['CHANNEL_LACP_MODE'] = 'active'
        else:
            key_dict['CHANNEL_LACP_MODE'] = 'on'
def ambiente_borda(user,rack, environment_list):

    ranges=dict()
    ranges['MAX']=None
    ranges['MIN']=None
    ranges_vlans = dict()

    try:
        ranges_vlans['BORDA_DSR_VLAN_MIN'] = int(get_variable("borda_dsr_vlan_min"))
        ranges_vlans['BORDA_DSR_VLAN_MAX'] = int(get_variable("borda_dsr_vlan_max"))
        ranges_vlans['BORDA_DMZ_VLAN_MIN'] = int(get_variable("borda_dmz_vlan_min"))
        ranges_vlans['BORDA_DMZ_VLAN_MAX'] = int(get_variable("borda_dmz_vlan_max"))
        ranges_vlans['BORDACACHOS_VLAN_MIN'] = int(get_variable("bordacachos_vlan_min"))
        ranges_vlans['BORDACACHOS_VLAN_MAX'] = int(get_variable("bordacachos_vlan_max"))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando as variáveis BORDA<DSR,DMZ,CACHOS>_VLAN_<MAX,MIN>.")
    try:
        base_vlan = int(get_variable("num_vlan_acl_bordadsr"))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável  NUM_VLAN_ACL_BORDADSR")

    ambientes=dict()
    vlans = dict()
    ambientes['LOG'] = "PRODUCAO"
    ambientes['L3']= rack.nome
    divisao_aclpaths = [['BORDA_DSR','BORDA-DSR', 'BordaVrf'],['BORDA_DMZ','BORDA-DMZ', 'BordaVrf'],['BORDACACHOS','BORDACACHOS', 'BordaCachosVrf']]

    for item in divisao_aclpaths:
        divisaodc = item[0]
        acl_path = item[1]
        vrf = item[2]

        vlan_min = divisaodc+"_VLAN_MIN"
        vlan_max = divisaodc+"_VLAN_MAX"
        ranges['MAX']= ranges_vlans.get(vlan_max)
        ranges['MIN']= ranges_vlans.get(vlan_min)

        ambientes['DC']= divisaodc
        env = criar_ambiente(user, ambientes,ranges, acl_path, "Servidores", vrf)
        environment_list.append(env)

        vlans['VLAN_NUM'] = base_vlan
        base_vlan += 1
        vlans['VLAN_NAME'] = "ACL_"+divisaodc+"_"+ambientes.get('L3')
        criar_vlan(user, vlans, ambientes, 1)

    return environment_list
示例#31
0
def autoprovision_coreoob(rack, FILEINCR1, FILEINCR2, FILEINOOB, name_core1,
                          name_core2, name_oob, name_lf1, name_lf2, ip_mgmtoob,
                          int_oob_core1, int_oob_core2, int_core1_oob,
                          int_core2_oob):

    # gerando dicionarios para substituir paravras chaves do roteiro
    variablestochangecore1 = {}
    variablestochangecore2 = {}
    variablestochangeoob = {}

    # nome dos cores, do console de gerencia dos lf do rack, e do rack
    HOSTNAME_CORE1 = name_core1
    HOSTNAME_CORE2 = name_core2
    HOSTNAME_OOB = name_oob
    HOSTNAME_RACK = HOSTNAME_OOB.split('-')
    HOSTNAME_LF1 = name_lf1
    HOSTNAME_LF2 = name_lf2

    # interfaces de conexão entre os cores e o console
    INT_OOBC1_UPLINK = int_oob_core1
    INT_OOBC2_UPLINK = int_oob_core2
    INTERFACE_CORE1 = int_core1_oob
    INTERFACE_CORE2 = int_core2_oob

    # ip de gerencia do oob
    IP_GERENCIA_OOB = ip_mgmtoob

    try:
        # roteiro para configuracao de core
        fileincore1 = get_variable('path_to_guide') + FILEINCR1
        fileincore2 = get_variable('path_to_guide') + FILEINCR2
        fileinoob = get_variable('path_to_guide') + FILEINOOB
        # valor base para as vlans e portchannels
        BASE_SO = int(get_variable('base_so'))
        # arquivos de saida, OOB-CM-01.cfg e OOB-CM-02.cfg
        fileoutcore1 = get_variable(
            'path_to_add_config'
        ) + HOSTNAME_CORE1 + '-ADD-' + HOSTNAME_RACK[2] + '.cfg'
        fileoutcore2 = get_variable(
            'path_to_add_config'
        ) + HOSTNAME_CORE2 + '-ADD-' + HOSTNAME_RACK[2] + '.cfg'
        fileoutoob = get_variable('path_to_config') + HOSTNAME_OOB + '.cfg'
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável PATH_TO_<GUIDE, CONFIG> ou BASE_SO.')
def _generate_dict(interface):

    try:
        supported_string = get_variable("supported_equipment_brands")
        SUPPORTED_EQUIPMENT_BRANDS = ast.literal_eval(supported_string)
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável supported_equipment_brands.")
    except ValueError:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável supported_equipment_brands. Formato invalido. Deve ser uma string no formato de lista."
        )

    # Check if it is a supported equipment interface

    if interface.equipamento.modelo.marca.nome not in SUPPORTED_EQUIPMENT_BRANDS:
        raise exceptions.UnsupportedEquipmentException()

    key_dict = {}
    # TODO Separate differet vendor support
    # Cisco Nexus 6001 dict
    key_dict["NATIVE_VLAN"] = interface.vlan_nativa
    key_dict["USE_MCLAG"] = 1
    key_dict["INTERFACE_NAME"] = interface.interface
    key_dict["INTERFACE_DESCRIPTION"] = (
        str(interface.ligacao_front.equipamento.nome) + " " + str(interface.ligacao_front.interface)
    )
    key_dict["INTERFACE_TYPE"] = interface.tipo.tipo
    if key_dict["INTERFACE_TYPE"] in "trunk":
        key_dict["VLAN_RANGE"] = get_vlan_range(interface)

    if interface.channel is not None:
        key_dict["BOOL_INTERFACE_IN_CHANNEL"] = 1
        key_dict["PORTCHANNEL_NAME"] = interface.channel.nome
        try:
            key_dict["MCLAG_IDENTIFIER"] = int(re.sub(r"[a-zA\-]", "", interface.channel.nome))
        except ValueError, e:
            log.error("Error: invalid channel name")
            raise e
        if interface.channel.lacp:
            key_dict["CHANNEL_LACP_MODE"] = "active"
        else:
            key_dict["CHANNEL_LACP_MODE"] = "on"
示例#33
0
def dic_lf_spn(user, rack):

    CIDREBGP = {}
    CIDRBE = {}
    ########
    VLANBELEAF = {}
    VLANFELEAF = {}
    VLANBORDALEAF = {}
    VLANBORDACACHOSLEAF = {}
    ########
    VLANBELEAF[rack] = []
    VLANFELEAF[rack] = []
    VLANBORDALEAF[rack] = []
    VLANBORDACACHOSLEAF[rack] = []

    ipv4_spn1 = dict()
    ipv4_spn2 = dict()
    ipv4_spn3 = dict()
    ipv4_spn4 = dict()
    redev6_spn1 = dict()
    redev6_spn2 = dict()
    redev6_spn3 = dict()
    redev6_spn4 = dict()

    try:
        BASE_RACK = int(get_variable('base_rack'))
        VLANBE = int(get_variable('vlanbe'))
        VLANFE = int(get_variable('vlanfe'))
        VLANBORDA = int(get_variable('vlanborda'))
        VLANBORDACACHOS = int(get_variable('vlanbordacachos'))
        VLANBETORxTOR = int(get_variable('vlanbetorxtor'))
        # CIDR sala 01 => 10.128.0.0/12
        CIDRBE[0] = IPNetwork(get_variable('cidr_sl01'))
        CIDREBGP[0] = IPNetwork(get_variable('cidr_bgp'))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável BASE_RACK ou VLAN<BE,FE,BORDA,CACHOS,TORxTOR> ou CIDR<BE,EBGP>.'
        )
示例#34
0
def dic_lf_spn(user, rack):

    CIDREBGP = {}
    CIDRBE = {}
    ########
    VLANBELEAF = {}
    VLANFELEAF = {}
    VLANBORDALEAF = {}
    VLANBORDACACHOSLEAF = {}
    ########
    VLANBELEAF[rack]=[]
    VLANFELEAF[rack]=[]
    VLANBORDALEAF[rack]=[]
    VLANBORDACACHOSLEAF[rack]=[]

    ipv4_spn1 = dict()
    ipv4_spn2 = dict()
    ipv4_spn3 = dict()
    ipv4_spn4 = dict()
    redev6_spn1 = dict()
    redev6_spn2 = dict()
    redev6_spn3 = dict()
    redev6_spn4 = dict()

    try:
        BASE_RACK = int(get_variable("base_rack"))
        VLANBE = int(get_variable("vlanbe"))
        VLANFE = int(get_variable("vlanfe"))
        VLANBORDA = int(get_variable("vlanborda"))
        VLANBORDACACHOS = int(get_variable("vlanbordacachos"))
        VLANBETORxTOR = int(get_variable("vlanbetorxtor"))
        #CIDR sala 01 => 10.128.0.0/12
        CIDRBE[0] = IPNetwork(get_variable("cidr_sl01"))
        CIDREBGP[0] = IPNetwork(get_variable("cidr_bgp"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável BASE_RACK ou VLAN<BE,FE,BORDA,CACHOS,TORxTOR> ou CIDR<BE,EBGP>.")
示例#35
0
def ambiente_prod_fe(user, rack, environment_list):

    redes, ranges, ipv6 = dic_fe_prod(rack.numero)

    ambientes = dict()
    ambientes['LOG'] = 'PRODUCAO'
    ambientes['L3'] = rack.nome
    ambientes['DC'] = 'FE'

    redes['TIPO'] = 'Rede invalida equipamentos'
    ipv6['TIPO'] = 'Rede invalida equipamentos'

    acl_path = 'FECLOUD'

    # criar ambiente
    env = criar_ambiente(user, ambientes, ranges, acl_path, 'Servidores',
                         'FEVrf')
    environment_list.append(env)

    # configuracao dos ambientes
    redes['VERSION'] = 'ipv4'
    config_ambiente(user, redes, ambientes)

    ipv6['VERSION'] = 'ipv6'
    config_ambiente(user, ipv6, ambientes)

    vlans = dict()
    try:
        vlans['VLAN_NUM'] = int(get_variable('num_vlan_acl_fe'))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável  NUM_VLAN_ACL_FE')

    vlans['VLAN_NAME'] = 'ACL_' + \
        ambientes.get('DC') + '_' + ambientes.get('L3')
    criar_vlan(user, vlans, ambientes, 1)

    return environment_list
def ambiente_prod_fe(user, rack, environment_list):

    redes, ranges, ipv6 = dic_fe_prod(rack.numero)

    ambientes = dict()
    ambientes['LOG'] = "PRODUCAO"
    ambientes['L3'] = rack.nome
    ambientes['DC'] = "FE"

    redes['TIPO'] = "Rede invalida equipamentos"
    ipv6['TIPO'] = "Rede invalida equipamentos"

    acl_path = 'FECLOUD'

    #criar ambiente
    env = criar_ambiente(user, ambientes, ranges, acl_path, "Servidores",
                         "FEVrf")
    environment_list.append(env)

    #configuracao dos ambientes
    redes['VERSION'] = "ipv4"
    config_ambiente(user, redes, ambientes)

    ipv6['VERSION'] = "ipv6"
    config_ambiente(user, ipv6, ambientes)

    vlans = dict()
    try:
        vlans['VLAN_NUM'] = int(get_variable("num_vlan_acl_fe"))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável  NUM_VLAN_ACL_FE")

    vlans['VLAN_NAME'] = "ACL_" + ambientes.get('DC') + "_" + ambientes.get(
        'L3')
    criar_vlan(user, vlans, ambientes, 1)

    return environment_list
示例#37
0
def autoprovision_coreoob(rack, FILEINCR1, FILEINCR2, FILEINOOB, name_core1, name_core2, name_oob, name_lf1, name_lf2, ip_mgmtoob, int_oob_core1, int_oob_core2, int_core1_oob, int_core2_oob ):

    #gerando dicionarios para substituir paravras chaves do roteiro
    variablestochangecore1={}
    variablestochangecore2={}
    variablestochangeoob={}

    #nome dos cores, do console de gerencia dos lf do rack, e do rack
    HOSTNAME_CORE1=name_core1
    HOSTNAME_CORE2=name_core2
    HOSTNAME_OOB=name_oob
    HOSTNAME_RACK = HOSTNAME_OOB.split("-")
    HOSTNAME_LF1 = name_lf1
    HOSTNAME_LF2 = name_lf2

    #interfaces de conexão entre os cores e o console
    INT_OOBC1_UPLINK = int_oob_core1
    INT_OOBC2_UPLINK = int_oob_core2
    INTERFACE_CORE1  = int_core1_oob
    INTERFACE_CORE2  = int_core2_oob

    #ip de gerencia do oob
    IP_GERENCIA_OOB = ip_mgmtoob

    try:
        #roteiro para configuracao de core
        fileincore1=get_variable("path_to_guide")+FILEINCR1
        fileincore2=get_variable("path_to_guide")+FILEINCR2
        fileinoob=get_variable("path_to_guide")+FILEINOOB
        #valor base para as vlans e portchannels
        BASE_SO = int(get_variable("base_so"))
        #arquivos de saida, OOB-CM-01.cfg e OOB-CM-02.cfg
        fileoutcore1=get_variable("path_to_add_config")+HOSTNAME_CORE1+"-ADD-"+HOSTNAME_RACK[2]+".cfg"
        fileoutcore2=get_variable("path_to_add_config")+HOSTNAME_CORE2+"-ADD-"+HOSTNAME_RACK[2]+".cfg"
        fileoutoob=get_variable("path_to_config")+HOSTNAME_OOB+".cfg"
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável PATH_TO_<GUIDE, CONFIG> ou BASE_SO.")
示例#38
0
def api_foreman(rack):

    try:
        NETWORKAPI_FOREMAN_URL = get_variable("foreman_url")
        NETWORKAPI_FOREMAN_USERNAME = get_variable("foreman_username")
        NETWORKAPI_FOREMAN_PASSWORD = get_variable("foreman_password")
        FOREMAN_HOSTS_ENVIRONMENT_ID = get_variable(
            "foreman_hosts_environment_id")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando as variáveis relativas ao Foreman.")

    foreman = Foreman(
        NETWORKAPI_FOREMAN_URL,
        (NETWORKAPI_FOREMAN_USERNAME, NETWORKAPI_FOREMAN_PASSWORD),
        api_version=2)

    # for each switch, check the switch ip against foreman know networks, finds foreman hostgroup
    # based on model and brand and inserts the host in foreman
    # if host already exists, delete and recreate with new information
    for [switch, mac] in [[rack.id_sw1, rack.mac_sw1],
                          [rack.id_sw2, rack.mac_sw2],
                          [rack.id_ilo, rack.mac_ilo]]:
        # Get all foremand subnets and compare with the IP address of the switches until find it
        if mac == None:
            raise RackConfigError(
                None, rack.nome,
                ("Could not create entry for %s. There is no mac address." %
                 switch.nome))

        ip = _buscar_ip(switch.id)
        if ip == None:
            raise RackConfigError(
                None, rack.nome,
                ("Could not create entry for %s. There is no management IP." %
                 switch.nome))

        switch_cadastrado = 0
        for subnet in foreman.subnets.index()['results']:
            network = IPNetwork(ip + '/' + subnet['mask']).network
            # check if switches ip network is the same as subnet['subnet']['network'] e subnet['subnet']['mask']
            if network.__str__() == subnet['network']:
                subnet_id = subnet['id']
                hosts = foreman.hosts.index(search=switch.nome)['results']
                if len(hosts) == 1:
                    foreman.hosts.destroy(id=hosts[0]['id'])
                elif len(hosts) > 1:
                    raise RackConfigError(None, rack.nome, (
                        "Could not create entry for %s. There are multiple entries "
                        "with the sam name." % switch.nome))

                # Lookup foreman hostgroup
                # By definition, hostgroup should be Marca+"_"+Modelo
                hostgroup_name = switch.modelo.marca.nome + "_" + switch.modelo.nome
                hostgroups = foreman.hostgroups.index(search=hostgroup_name)
                if len(hostgroups['results']) == 0:
                    raise RackConfigError(
                        None, rack.nome,
                        "Could not create entry for %s. Could not find hostgroup %s "
                        "in foreman." % (switch.nome, hostgroup_name))
                elif len(hostgroups['results']) > 1:
                    raise RackConfigError(
                        None, rack.nome,
                        "Could not create entry for %s. Multiple hostgroups %s found"
                        " in Foreman." % (switch.nome, hostgroup_name))
                else:
                    hostgroup_id = hostgroups['results'][0]['id']

                host = foreman.hosts.create(
                    host={
                        'name': switch.nome,
                        'ip': ip,
                        'mac': mac,
                        'environment_id': FOREMAN_HOSTS_ENVIRONMENT_ID,
                        'hostgroup_id': hostgroup_id,
                        'subnet_id': subnet_id,
                        'build': 'true',
                        'overwrite': 'true'
                    })
                switch_cadastrado = 1

        if not switch_cadastrado:
            raise RackConfigError(
                None, rack.nome,
                "Unknown error. Could not create entry for %s in foreman." %
                switch.nome)
示例#39
0
def autoprovision_splf(rack, equips):

    log.info("AutoprovisionSPN-LF")

    numero_rack = rack.numero
    prefixspn = "SPN"
    prefixlf = "LF-"
    prefixoob = "OOB"
    # STRUCTURE: IPSPINE[rack][spine]: ip a configurar no spine 'spine' relativo à leaf do rack 'rack'
    # STRUCTURE: IPLEAF[rack][spine]: ip a configurar no leaf do rack 'rack' relativo ao spine 'spine'
    CIDREBGP = dict()
    IPSPINEipv4 = dict()
    IPSPINEipv6 = dict()
    IPLEAFipv4 = dict()
    IPLEAFipv6 = dict()
    IPSIBGPipv4 = dict()
    IPSIBGPipv6 = dict()
    ASLEAF = dict()
    #
    VLANBELEAF = dict()
    VLANFELEAF = dict()
    VLANBORDALEAF = dict()
    VLANBORDACACHOSLEAF = dict()
    VLANBORDACACHOSBLEAF = dict()
    #
    PODSBEipv4 = dict()
    redesPODSBEipv4 = dict()
    #
    subnetsRackBEipv4 = dict()
    #
    PODSBEipv6 = dict()
    redesPODSBEipv6 = dict()
    PODSBEFEipv6 = dict()
    redesPODSBEFEipv6 = dict()
    PODSBEBOipv6 = dict()
    redesPODSBEBOipv6 = dict()
    PODSBECAipv6 = dict()
    redesPODSBECAipv6 = dict()
    redesHostsipv6 = dict()
    redeHostsBEipv6 = dict()
    redeHostsFEipv6 = dict()
    redeHostsBOipv6 = dict()
    redeHostsCAipv6 = dict()
    redeHostsFILERipv6 = dict()
    subnetsRackBEipv6 = dict()
    subnetsRackFEipv4 = dict()
    subnetsRackBO_DSRipv4 = dict()
    subnetsRackBOCAAipv4 = dict()
    subnetsRackBOCABipv4 = dict()
    redesPODSFEipv4 = dict()
    subnetsRackFEipv6 = dict()
    subnetsRackBO_DSRipv6 = dict()
    subnetsRackBOCAAipv6 = dict()
    subnetsRackBOCABipv6 = dict()
    redesPODSFEipv6 = dict()
    #
    IPSPINEipv4[numero_rack] = list()
    IPSPINEipv6[numero_rack] = list()
    IPLEAFipv4[numero_rack] = list()
    IPLEAFipv6[numero_rack] = list()
    IPSIBGPipv4[numero_rack] = list()
    IPSIBGPipv6[numero_rack] = list()
    VLANBELEAF[numero_rack] = list()
    VLANFELEAF[numero_rack] = list()
    VLANBORDALEAF[numero_rack] = list()
    VLANBORDACACHOSLEAF[numero_rack] = list()
    VLANBORDACACHOSBLEAF[numero_rack] = list()
    ASLEAF[numero_rack] = list()
    #
    PODSBEipv4[numero_rack] = list()
    redesPODSBEipv4[numero_rack] = list()
    #
    subnetsRackBEipv4[numero_rack] = list()
    #
    PODSBEipv6[numero_rack] = list()
    redesPODSBEipv6[numero_rack] = list()
    PODSBEFEipv6[numero_rack] = list()
    redesPODSBEFEipv6[numero_rack] = list()
    PODSBEBOipv6[numero_rack] = list()
    redesPODSBEBOipv6[numero_rack] = list()
    PODSBECAipv6[numero_rack] = list()
    redesPODSBECAipv6[numero_rack] = list()
    redesHostsipv6[numero_rack] = list()
    redeHostsBEipv6[numero_rack] = list()
    redeHostsFEipv6[numero_rack] = list()
    redeHostsBOipv6[numero_rack] = list()
    redeHostsCAipv6[numero_rack] = list()
    redeHostsFILERipv6[numero_rack] = list()
    subnetsRackBEipv6[numero_rack] = list()
    subnetsRackFEipv4[numero_rack] = list()
    subnetsRackBO_DSRipv4[numero_rack] = list()
    subnetsRackBOCAAipv4[numero_rack] = list()
    subnetsRackBOCABipv4[numero_rack] = list()
    redesPODSFEipv4[numero_rack] = list()
    subnetsRackFEipv6[numero_rack] = list()
    subnetsRackBO_DSRipv6[numero_rack] = list()
    subnetsRackBOCAAipv6[numero_rack] = list()
    subnetsRackBOCABipv6[numero_rack] = list()
    redesPODSFEipv6[numero_rack] = list()

    CIDRFEipv4 = dict()
    CIDRFEipv6 = dict()

    variablestochangespine1 = dict()
    variablestochangeleaf1 = dict()

    VLANBE = None
    VLANFE = None
    VLANBORDA = None
    VLANBORDACACHOS = None
    CIDRBEipv4 = None
    CIDRBEipv6 = None

    CIDRBO_DSRipv4interno = ""
    prefixInternoBO_DSRV4 = ""
    CIDRBO_DSRipv6interno = ""
    prefixInternoBO_DSRV6 = ""
    CIDRBOCAAipv4interno = ""
    prefixInternoBOCAAV4 = ""
    CIDRBOCAAipv6interno = ""
    prefixInternoBOCAAV6 = ""
    CIDRBOCABipv4interno = ""
    prefixInternoBOCABV4 = ""
    CIDRBOCABipv6interno = ""
    prefixInternoBOCABV6 = ""

    try:
        path_to_guide = get_variable("path_to_guide")
        path_to_add_config = get_variable("path_to_add_config")
        path_to_config = get_variable("path_to_config")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável PATH_TO_GUIDE")

    try:
        variablestochangeleaf1["KICKSTART_SO_LF"] = get_variable(
            "kickstart_so_lf")
        variablestochangeleaf1["IMAGE_SO_LF"] = get_variable("image_so_lf")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável KICKSTART_SO_LF ou IMAGE_SO_LF.")

    equips_sorted = sorted(equips, key=operator.itemgetter('sw'))

    dcroom = model_to_dict(rack.dcroom)
    log.debug("type: %s" % str(type(dcroom.get("config"))))
    fabricconfig = dcroom.get("config")

    try:
        fabricconfig = json.loads(fabricconfig)
        log.debug("type -ast: %s" % str(type(fabricconfig)))
    except:
        pass

    try:
        fabricconfig = ast.literal_eval(fabricconfig)
        log.debug("config -ast: %s" % str(fabricconfig))
    except:
        pass

    envconfig = fabricconfig
    BASE_RACK = dcroom.get("racks")
    BGP = envconfig.get("BGP")
    BASE_AS_SPN = int(BGP.get("spines"))
    BASE_AS_LFS = int(BGP.get("leafs"))

    # get fathers environments
    spn_envs = models_env.Ambiente.objects.filter(
        dcroom=dcroom.get("id"),
        father_environment__isnull=True,
        ambiente_logico__nome="SPINES")

    prod_envs = models_env.Ambiente.objects.filter(
        dcroom=dcroom.get("id"),
        father_environment__isnull=True,
        ambiente_logico__nome="PRODUCAO",
        divisao_dc__nome__in=[
            "BE", "FE", "BO_DSR", "BOCACHOS-A", "BOCACHOS-B"
        ])

    lf_env = models_env.Ambiente.objects.filter(
        dcroom=dcroom.get("id"),
        divisao_dc__nome="BE",
        grupo_l3__nome=str(rack.dcroom.name),
        ambiente_logico__nome="LEAF-LEAF").uniqueResult()
    for spn in spn_envs:
        if spn.divisao_dc.nome[:2] == "BE":
            VLANBE = spn.min_num_vlan_1
            for net in spn.configs:
                if net.ip_config.type == "v4":
                    CIDRBEipv4 = IPNetwork(str(net.ip_config.subnet))
                    prefixBEV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRBEipv6 = IPNetwork(str(net.ip_config.subnet))
                    prefixBEV6 = int(net.ip_config.new_prefix)
        elif spn.divisao_dc.nome[:2] == "FE":
            VLANFE = spn.min_num_vlan_1
            for net in spn.configs:
                if net.ip_config.type == "v4":
                    CIDRFEipv4 = IPNetwork(str(net.ip_config.subnet))
                    prefixFEV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRFEipv6 = IPNetwork(str(net.ip_config.subnet))
                    prefixFEV6 = int(net.ip_config.new_prefix)
        elif spn.divisao_dc.nome == "BO":
            VLANBORDA = spn.min_num_vlan_1
        elif spn.divisao_dc.nome == "BOCACHOS-A":
            VLANBORDACACHOS = spn.min_num_vlan_1
        elif spn.divisao_dc.nome == "BOCACHOS-B":
            VLANBORDACACHOSB = spn.min_num_vlan_1

    for prod in prod_envs:
        if prod.divisao_dc.nome[:2] == "BE":
            for net in prod.configs:
                if net.ip_config.type == "v4":
                    CIDRBEipv4interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRBEipv6interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoV6 = int(net.ip_config.new_prefix)
        elif prod.divisao_dc.nome[:2] == "FE":
            for net in prod.configs:
                if net.ip_config.type == "v4":
                    CIDRFEipv4interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoFEV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRFEipv6interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoFEV6 = int(net.ip_config.new_prefix)
        elif prod.divisao_dc.nome == "BO_DSR":
            for net in prod.configs:
                if net.ip_config.type == "v4":
                    CIDRBO_DSRipv4interno = IPNetwork(str(
                        net.ip_config.subnet))
                    prefixInternoBO_DSRV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRBO_DSRipv6interno = IPNetwork(str(
                        net.ip_config.subnet))
                    prefixInternoBO_DSRV6 = int(net.ip_config.new_prefix)
        elif prod.divisao_dc.nome == "BOCACHOS-A":
            for net in prod.configs:
                if net.ip_config.type == "v4":
                    CIDRBOCAAipv4interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoBOCAAV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRBOCAAipv6interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoBOCAAV6 = int(net.ip_config.new_prefix)
        elif prod.divisao_dc.nome == "BOCACHOS-B":
            for net in prod.configs:
                if net.ip_config.type == "v4":
                    CIDRBOCABipv4interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoBOCABV4 = int(net.ip_config.new_prefix)
                else:
                    log.debug(str(net.ip_config.subnet))
                    CIDRBOCABipv6interno = IPNetwork(str(net.ip_config.subnet))
                    prefixInternoBOCABV6 = int(net.ip_config.new_prefix)

    log.debug(str(lf_env))
    for netlf in lf_env.configs:
        if netlf.ip_config.type == "v4":
            IBGPToRLxLipv4 = IPNetwork(str(netlf.ip_config.subnet))
        elif netlf.ip_config.type == "v6":
            IBGPToRLxLipv6 = IPNetwork(str(netlf.ip_config.subnet))

    SPINE1ipv4 = splitnetworkbyrack(CIDRBEipv4, prefixBEV4, 0)
    SPINE2ipv4 = splitnetworkbyrack(CIDRBEipv4, prefixBEV4, 1)
    SPINE3ipv4 = splitnetworkbyrack(CIDRBEipv4, prefixBEV4, 2)
    SPINE4ipv4 = splitnetworkbyrack(CIDRBEipv4, prefixBEV4, 3)
    SPINE1ipv6 = splitnetworkbyrack(CIDRBEipv6, prefixBEV6, 0)
    SPINE2ipv6 = splitnetworkbyrack(CIDRBEipv6, prefixBEV6, 1)
    SPINE3ipv6 = splitnetworkbyrack(CIDRBEipv6, prefixBEV6, 2)
    SPINE4ipv6 = splitnetworkbyrack(CIDRBEipv6, prefixBEV6, 3)

    id_vlt = [
        envconfig.get("VLT").get("id_vlt_lf1"),
        envconfig.get("VLT").get("id_vlt_lf2")
    ]
    priority_vlt = [
        envconfig.get("VLT").get("priority_vlt_lf1"),
        envconfig.get("VLT").get("priority_vlt_lf2")
    ]

    subSPINE1ipv4 = list(SPINE1ipv4.subnet(31))
    subSPINE2ipv4 = list(SPINE2ipv4.subnet(31))
    subSPINE3ipv4 = list(SPINE3ipv4.subnet(31))
    subSPINE4ipv4 = list(SPINE4ipv4.subnet(31))
    subSPINE1ipv6 = list(SPINE1ipv6.subnet(127))
    subSPINE2ipv6 = list(SPINE2ipv6.subnet(127))
    subSPINE3ipv6 = list(SPINE3ipv6.subnet(127))
    subSPINE4ipv6 = list(SPINE4ipv6.subnet(127))

    subIBGPToRLxLipv4 = list(IBGPToRLxLipv4.subnet(31))
    subIBGPToRLxLipv6 = list(IBGPToRLxLipv6.subnet(127))

    IPSPINEipv4[numero_rack].append(subSPINE1ipv4[numero_rack][0])
    IPSPINEipv4[numero_rack].append(subSPINE2ipv4[numero_rack][0])
    IPSPINEipv4[numero_rack].append(subSPINE3ipv4[numero_rack][0])
    IPSPINEipv4[numero_rack].append(subSPINE4ipv4[numero_rack][0])
    #
    IPLEAFipv4[numero_rack].append(subSPINE1ipv4[numero_rack][1])
    IPLEAFipv4[numero_rack].append(subSPINE2ipv4[numero_rack][1])
    IPLEAFipv4[numero_rack].append(subSPINE3ipv4[numero_rack][1])
    IPLEAFipv4[numero_rack].append(subSPINE4ipv4[numero_rack][1])
    #
    IPSIBGPipv4[numero_rack].append(subIBGPToRLxLipv4[numero_rack][0])
    IPSIBGPipv4[numero_rack].append(subIBGPToRLxLipv4[numero_rack][1])
    #
    IPSPINEipv6[numero_rack].append(subSPINE1ipv6[numero_rack][0])
    IPSPINEipv6[numero_rack].append(subSPINE2ipv6[numero_rack][0])
    IPSPINEipv6[numero_rack].append(subSPINE3ipv6[numero_rack][0])
    IPSPINEipv6[numero_rack].append(subSPINE4ipv6[numero_rack][0])
    #
    IPLEAFipv6[numero_rack].append(subSPINE1ipv6[numero_rack][1])
    IPLEAFipv6[numero_rack].append(subSPINE2ipv6[numero_rack][1])
    IPLEAFipv6[numero_rack].append(subSPINE3ipv6[numero_rack][1])
    IPLEAFipv6[numero_rack].append(subSPINE4ipv6[numero_rack][1])
    #
    IPSIBGPipv6[numero_rack].append(subIBGPToRLxLipv6[numero_rack][0])
    IPSIBGPipv6[numero_rack].append(subIBGPToRLxLipv6[numero_rack][1])
    #
    VLANBELEAF[numero_rack].append(VLANBE + numero_rack)
    VLANBELEAF[numero_rack].append(VLANBE + numero_rack + BASE_RACK)
    VLANBELEAF[numero_rack].append(VLANBE + numero_rack + 2 * BASE_RACK)
    VLANBELEAF[numero_rack].append(VLANBE + numero_rack + 3 * BASE_RACK)
    #
    VLANFELEAF[numero_rack].append(VLANFE + numero_rack)
    VLANFELEAF[numero_rack].append(VLANFE + numero_rack + BASE_RACK)
    VLANFELEAF[numero_rack].append(VLANFE + numero_rack + 2 * BASE_RACK)
    VLANFELEAF[numero_rack].append(VLANFE + numero_rack + 3 * BASE_RACK)
    #
    VLANBORDALEAF[numero_rack].append(VLANBORDA + numero_rack)
    VLANBORDALEAF[numero_rack].append(VLANBORDA + numero_rack + BASE_RACK)
    VLANBORDALEAF[numero_rack].append(VLANBORDA + numero_rack + 2 * BASE_RACK)
    VLANBORDALEAF[numero_rack].append(VLANBORDA + numero_rack + 3 * BASE_RACK)
    #
    VLANBORDACACHOSLEAF[numero_rack].append(VLANBORDACACHOS + numero_rack)
    VLANBORDACACHOSLEAF[numero_rack].append(VLANBORDACACHOS + numero_rack +
                                            BASE_RACK)
    VLANBORDACACHOSLEAF[numero_rack].append(VLANBORDACACHOS + numero_rack +
                                            2 * BASE_RACK)
    VLANBORDACACHOSLEAF[numero_rack].append(VLANBORDACACHOS + numero_rack +
                                            3 * BASE_RACK)
    #
    VLANBORDACACHOSBLEAF[numero_rack].append(VLANBORDACACHOSB + numero_rack)
    VLANBORDACACHOSBLEAF[numero_rack].append(VLANBORDACACHOSB + numero_rack +
                                             BASE_RACK)
    VLANBORDACACHOSBLEAF[numero_rack].append(VLANBORDACACHOSB + numero_rack +
                                             2 * BASE_RACK)
    VLANBORDACACHOSBLEAF[numero_rack].append(VLANBORDACACHOSB + numero_rack +
                                             3 * BASE_RACK)
    #
    ASLEAF[numero_rack].append(BASE_AS_LFS + numero_rack)
    #          ::::::: SUBNETING FOR RACK NETWORKS - /19 :::::::
    # Redes p/ rack => 10.128.0.0/19, 10.128.32.0/19 , ... ,10.143.224.0/19
    subnetsRackBEipv4[numero_rack] = splitnetworkbyrack(
        CIDRBEipv4interno, prefixInternoV4, numero_rack)
    subnetsRackBEipv6[numero_rack] = splitnetworkbyrack(
        CIDRBEipv6interno, prefixInternoV6, numero_rack)
    # PODS BE => /20
    #    ::::::::::::::::::::::::::::::::::: FRONTEND
    #          ::::::: SUBNETING FOR RACK NETWORKS - /19 :::::::
    # Sumário do rack => 172.20.0.0/21
    subnetsRackFEipv4[numero_rack] = splitnetworkbyrack(
        CIDRFEipv4interno, prefixInternoFEV4, numero_rack)
    subnetsRackFEipv6[numero_rack] = splitnetworkbyrack(
        CIDRFEipv6interno, prefixInternoFEV6, numero_rack)
    #
    if CIDRBO_DSRipv4interno:
        subnetsRackBO_DSRipv4[numero_rack] = splitnetworkbyrack(
            CIDRBO_DSRipv4interno, prefixInternoBO_DSRV4, numero_rack)
        subnetsRackBO_DSRipv6[numero_rack] = splitnetworkbyrack(
            CIDRBO_DSRipv6interno, prefixInternoBO_DSRV6, numero_rack)
    #
    if CIDRBOCAAipv4interno:
        subnetsRackBOCAAipv4[numero_rack] = splitnetworkbyrack(
            CIDRBOCAAipv4interno, prefixInternoBOCAAV4, numero_rack)
        subnetsRackBOCAAipv6[numero_rack] = splitnetworkbyrack(
            CIDRBOCAAipv6interno, prefixInternoBOCAAV6, numero_rack)
    #
    if CIDRBOCABipv4interno:
        subnetsRackBOCABipv4[numero_rack] = splitnetworkbyrack(
            CIDRBOCABipv4interno, prefixInternoBOCABV4, numero_rack)
        subnetsRackBOCABipv6[numero_rack] = splitnetworkbyrack(
            CIDRBOCABipv6interno, prefixInternoBOCABV6, numero_rack)
    #          ::::::: SUBNETING EACH RACK NETWORK:::::::
    # PODS FE => 128 redes /28 ; 128 redes /64
    # redesPODSBEipv4[numero_rack] = list(subnetsRackFEipv4[numero_rack].subnet(28))
    # redesPODSBEipv6[numero_rack] = list(subnetsRackFEipv6[numero_rack].subnet(64))

    for equip, spn, j in zip(equips_sorted[:2], [0, 2], [0, 1]):
        # lf 1/2
        log.info("for equip spn j")
        variablestochangeleaf1["IPLEAFSP1IPV4"] = str(
            IPLEAFipv4[numero_rack][spn])
        variablestochangeleaf1["IPLEAFSP2IPV4"] = str(
            IPLEAFipv4[numero_rack][spn + 1])
        variablestochangeleaf1["IPIBGPIPV4"] = str(IPSIBGPipv4[numero_rack][j])
        variablestochangeleaf1["IPLEAFSP1IPV6"] = str(
            IPLEAFipv6[numero_rack][spn])
        variablestochangeleaf1["IPLEAFSP2IPV6"] = str(
            IPLEAFipv6[numero_rack][spn + 1])
        variablestochangeleaf1["IPIBGPIPV6"] = str(IPSIBGPipv6[numero_rack][j])

        variablestochangeleaf1["VLANBELEAFSP1"] = str(
            VLANBELEAF[numero_rack][spn])
        variablestochangeleaf1["VLANBELEAFSP2"] = str(
            VLANBELEAF[numero_rack][spn + 1])
        variablestochangeleaf1["VLANFELEAFSP1"] = str(
            VLANFELEAF[numero_rack][spn])
        variablestochangeleaf1["VLANFELEAFSP2"] = str(
            VLANFELEAF[numero_rack][spn + 1])
        variablestochangeleaf1["VLANBORDALEAFSP1"] = str(
            VLANBORDALEAF[numero_rack][spn])
        variablestochangeleaf1["VLANBORDALEAFSP2"] = str(
            VLANBORDALEAF[numero_rack][spn + 1])
        variablestochangeleaf1["VLANBORDACACHOSLEAFSP1"] = str(
            VLANBORDACACHOSLEAF[numero_rack][spn])
        variablestochangeleaf1["VLANBORDACACHOSLEAFSP2"] = str(
            VLANBORDACACHOSLEAF[numero_rack][spn + 1])
        variablestochangeleaf1["VLANBORDACACHOSBLEAFSP1"] = str(
            VLANBORDACACHOSBLEAF[numero_rack][spn])
        variablestochangeleaf1["VLANBORDACACHOSBLEAFSP2"] = str(
            VLANBORDACACHOSBLEAF[numero_rack][spn + 1])

        variablestochangeleaf1["ASLEAF"] = str(ASLEAF[numero_rack][0])

        variablestochangeleaf1["IPNEIGHSPINE1IPV4"] = str(
            IPSPINEipv4[numero_rack][spn])
        variablestochangeleaf1["IPNEIGHSPINE2IPV4"] = str(
            IPSPINEipv4[numero_rack][spn + 1])
        variablestochangeleaf1["IPNEIGHSPINE1IPV6"] = str(
            IPSPINEipv6[numero_rack][spn])
        variablestochangeleaf1["IPNEIGHSPINE2IPV6"] = str(
            IPSPINEipv6[numero_rack][spn + 1])

        if equip.get("nome")[-1] == "1":
            log.debug("lf-name: %s. Ip: %s" %
                      (equip.get("nome"), IPSIBGPipv4[numero_rack][1]))
            variablestochangeleaf1["IPNEIGHIBGPIPV4"] = str(
                IPSIBGPipv4[numero_rack][1])
            variablestochangeleaf1["IPNEIGHIBGPIPV6"] = str(
                IPSIBGPipv6[numero_rack][1])
        else:
            log.debug("lf-name: %s. Ip: %s" %
                      (equip.get("nome"), IPSIBGPipv4[numero_rack][0]))
            variablestochangeleaf1["IPNEIGHIBGPIPV4"] = str(
                IPSIBGPipv4[numero_rack][0])
            variablestochangeleaf1["IPNEIGHIBGPIPV6"] = str(
                IPSIBGPipv6[numero_rack][0])

        variablestochangeleaf1["NET_HOST_BE_IPV4"] = str(
            subnetsRackBEipv4[numero_rack])
        variablestochangeleaf1["NET_HOST_FE_IPV4"] = str(
            subnetsRackFEipv4[numero_rack])
        if CIDRBO_DSRipv4interno:
            variablestochangeleaf1["NET_HOST_BO_DSR_IPV4"] = str(
                subnetsRackBO_DSRipv4[numero_rack])
        if CIDRBOCAAipv4interno:
            variablestochangeleaf1["NET_HOST_BOCAA_IPV4"] = str(
                subnetsRackBOCAAipv4[numero_rack])
        if CIDRBOCABipv4interno:
            variablestochangeleaf1["NET_HOST_BOCAB_IPV4"] = str(
                subnetsRackBOCABipv4[numero_rack])
        variablestochangeleaf1["NET_SPINE1_LF_IPV4"] = str(
            subSPINE1ipv4[numero_rack])
        variablestochangeleaf1["NET_SPINE2_LF_IPV4"] = str(
            subSPINE2ipv4[numero_rack])
        variablestochangeleaf1["NET_LF_LF_IPV4"] = str(
            subIBGPToRLxLipv4[numero_rack])
        variablestochangeleaf1["NET_HOST_BE_IPV6"] = str(
            subnetsRackBEipv6[numero_rack])
        variablestochangeleaf1["NET_HOST_FE_IPV6"] = str(
            subnetsRackFEipv6[numero_rack])
        if CIDRBO_DSRipv6interno:
            variablestochangeleaf1["NET_HOST_BO_DSR_IPV6"] = str(
                subnetsRackBO_DSRipv6[numero_rack])
        if CIDRBOCAAipv6interno:
            variablestochangeleaf1["NET_HOST_BOCAA_IPV6"] = str(
                subnetsRackBOCAAipv6[numero_rack])
        if CIDRBOCABipv6interno:
            variablestochangeleaf1["NET_HOST_BOCAB_IPV6"] = str(
                subnetsRackBOCABipv6[numero_rack])
        variablestochangeleaf1["NET_SPINE1_LF_IPV6"] = str(
            subSPINE1ipv6[numero_rack])
        variablestochangeleaf1["NET_SPINE2_LF_IPV6"] = str(
            subSPINE2ipv6[numero_rack])
        variablestochangeleaf1["NET_LF_LF_IPV6"] = str(
            subIBGPToRLxLipv6[numero_rack])

        variablestochangeleaf1["ID_LEAF"] = str(equip.get("sw"))  # lf1 ou lf2
        variablestochangeleaf1["OWN_IP_MGMT"] = equip.get("ip_mngt")
        variablestochangeleaf1["LF_HOSTNAME"] = equip.get("nome")

        for i in equip.get("interfaces"):
            log.info("for i in equip")
            log.info(str(type(i.get("nome")[:3])))

            if i.get("nome")[:3] == prefixlf:
                variablestochangeleaf1["LFNEIGH_HOSTNAME"] = i.get("nome")
                variablestochangeleaf1["LFNEIGH_IP_MGMT"] = i.get("ip_mngt")
            elif i.get("nome")[:3] == prefixspn:
                spine_num = int(i.get("nome")[-1])
                variablestochangespine1["ASSPINE"] = str(BASE_AS_SPN +
                                                         spine_num - 1)
                variablestochangespine1["INTERFACE"] = i.get("interface")
                variablestochangespine1["LEAFNAME"] = equip.get("nome")
                variablestochangespine1["INT_LF_UPLINK"] = i.get(
                    "eq_interface")
                variablestochangespine1["IPSPINEIPV4"] = str(
                    IPSPINEipv4[numero_rack][spine_num - 1])
                variablestochangespine1["IPSPINEIPV6"] = str(
                    IPSPINEipv6[numero_rack][spine_num - 1])
                variablestochangespine1["VLANBELEAF"] = str(
                    VLANBELEAF[numero_rack][spine_num - 1])
                variablestochangespine1["VLANFELEAF"] = str(
                    VLANFELEAF[numero_rack][spine_num - 1])
                variablestochangespine1["VLANBORDALEAF"] = str(
                    VLANBORDALEAF[numero_rack][spine_num - 1])
                variablestochangespine1["VLANBORDACACHOSLEAF"] = str(
                    VLANBORDACACHOSLEAF[numero_rack][spine_num - 1])
                variablestochangespine1["VLANBORDACACHOSBLEAF"] = str(
                    VLANBORDACACHOSBLEAF[numero_rack][spine_num - 1])
                variablestochangespine1["ASLEAF"] = str(ASLEAF[numero_rack][0])
                variablestochangespine1["IPNEIGHLEAFIPV4"] = str(
                    IPLEAFipv4[numero_rack][spine_num - 1])
                variablestochangespine1["IPNEIGHLEAFIPV6"] = str(
                    IPLEAFipv6[numero_rack][spine_num - 1])
                if spine_num in [1, 3]:
                    variablestochangeleaf1["SP1_HOSTNAME"] = i.get("nome")
                    variablestochangeleaf1["INTERFACE_SP1"] = i.get(
                        "interface")
                    variablestochangeleaf1["ASSPINE1"] = str(BASE_AS_SPN +
                                                             spine_num - 1)
                else:
                    variablestochangeleaf1["SP2_HOSTNAME"] = i.get("nome")
                    variablestochangeleaf1["INTERFACE_SP2"] = i.get(
                        "interface")
                    variablestochangeleaf1["ASSPINE2"] = str(BASE_AS_SPN +
                                                             spine_num - 1)
                fileinspine1 = path_to_guide + i.get("roteiro")
                fileoutspine1 = path_to_add_config + i.get(
                    "nome") + "-ADD-" + rack.nome + ".cfg"
                replace(fileinspine1, fileoutspine1, variablestochangespine1)
                variablestochangespine1 = dict()
            elif i.get("nome")[:3] == prefixoob:
                variablestochangeleaf1["HOSTNAME_OOB"] = i.get("nome")
                variablestochangeleaf1["INTERFACE_OOB"] = i.get("interface")

        variablestochangeleaf1["ID_VLT"] = str(id_vlt[j])
        variablestochangeleaf1["PRIORITY_VLT"] = str(priority_vlt[j])

        fileinleaf1 = path_to_guide + equip.get("roteiro")
        fileoutleaf1 = path_to_config + equip.get("nome") + ".cfg"

        replace(fileinleaf1, fileoutleaf1, variablestochangeleaf1)
        variablestochangeleaf1 = dict()

    return True
示例#40
0
            logging.critical('Unable to connect to BIG-IP. Details: %s' % (e))
            raise base_exceptions.CommandErrorException(e)
        else:
            log.info('Connected in hostname:%s' % hostname)
            try:
                self._version = self._channel.System.SystemInfo.get_version()

                if self._version[8:len(self._version)].split('.')[0] <= 10:
                    raise base_exceptions.UnsupportedVersion(
                        'This plugin only supports BIG-IP v11 or above')
                else:
                    if session:
                        log.info('Try get new session')
                        session_cur = self._channel.System.Session.get_session_timeout()
                        log.info('Session Timeout Current: %s' % session_cur)
                        session_timeout = get_variable(
                            'set_session_timeout_plugin_f5', '60')
                        if int(session_cur) > int(session_timeout):
                            self._channel.System.Session.set_session_timeout(
                                session_timeout)
                        self._channel = self.get_session()
            except Exception, e:
                log.error(e)
                raise base_exceptions.CommandErrorException(e)

    def get_session(self):

        try:
            channel = self._channel.with_session_id()
            log.info('Session %s', channel)
        except Exception, e:
            if 'There are too many existing user sessions.'.lower() in str(e).lower():
示例#41
0
from networkapi.api_environment import facade as facade_env
from networkapi.infrastructure.xml_utils import dumps_networkapi
from networkapi.vlan import models as models_vlan
from networkapi.api_vlan.facade import v3 as facade_vlan_v3
from networkapi.equipamento.models import Equipamento, EquipamentoRoteiro
from networkapi.interface.models import Interface, InterfaceNotFoundError
from networkapi.ip.models import IpEquipamento, Ip
from networkapi.rack.models import Rack, Datacenter, DatacenterRooms, RackConfigError, RackError, RackNumberNotFoundError
from networkapi.rest import RestResource, UserNotAuthorizedError
from networkapi.api_rack import serializers as rack_serializers
from networkapi.api_rack import exceptions, autoprovision
from networkapi.system import exceptions as var_exceptions
from networkapi.system.facade import get_value as get_variable
from networkapi.api_rest.exceptions import ValidationAPIException, ObjectDoesNotExistException, NetworkAPIException

if int(get_variable('use_foreman')):
    from foreman.client import Foreman, ForemanException

log = logging.getLogger(__name__)


def save_dc(dc_dict):

    dc = Datacenter()

    dc.dcname = dc_dict.get('dcname')
    dc.address = dc_dict.get('address')

    dc.save_dc()
    return dc
示例#42
0
    def handle_post(self, request, user, *args, **kwargs):
        """Treat requests POST to create the configuration file.

        URL: rack/alocar-config/id_rack
        """
        try:

            # 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)

            # Validar configuracao
            if not rack.config:
                raise RackAplError(
                    None, rack.nome,
                    'Os arquivos de configuracao devem ser gerados antes.')

            if rack.create_vlan_amb:
                raise RackAplError(
                    None, rack.nome,
                    'As vlans, redes e ambientes ja foram criados.')

            # variaveis
            name_core1, name_core2 = get_core_name(rack)

            environment_list = []

            variablestochangecore1 = {}
            variablestochangecore2 = {}
            variablestochangecore1 = dic_vlan_core(variablestochangecore1,
                                                   rack.numero, name_core1,
                                                   rack.nome)
            variablestochangecore2 = dic_vlan_core(variablestochangecore2,
                                                   rack.numero, name_core2,
                                                   rack.nome)

            # VLAN Gerencia SO
            ambientes = dict()
            try:
                DIVISAODC_MGMT = get_variable('divisaodc_mngt')
                AMBLOG_MGMT = get_variable('amblog_mngt')
                GRPL3_MGMT = get_variable('grpl3_mngt')
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException(
                    'Erro buscando as variáveis <DIVISAODC,AMBLOG,GRPL3>_MGMT.'
                )

            ambientes['DC'] = DIVISAODC_MGMT
            ambientes['LOG'] = AMBLOG_MGMT
            ambientes['L3'] = GRPL3_MGMT

            try:
                # criar vlan
                vlan = criar_vlan(user, variablestochangecore1, ambientes)
            except:
                raise RackAplError(None, rack.nome, 'Erro ao criar a VLAN_SO.')
            try:
                # criar rede
                network = criar_rede(user, 'Rede invalida equipamentos',
                                     variablestochangecore1, vlan)
            except:
                raise RackAplError(None, rack.nome,
                                   'Erro ao criar a rede da VLAN_SO')
            try:
                # inserir os Core
                inserir_equip(user, variablestochangecore1, network.id)
                inserir_equip(user, variablestochangecore2, network.id)
            except:
                raise RackAplError(None, rack.nome,
                                   'Erro ao inserir o core 1 e 2')

            # Ambientes

            # BE - SPINE - LEAF
            try:
                environment_list = ambiente_spn_lf(user, rack,
                                                   environment_list)
            except:
                raise RackAplError(
                    None, rack.nome,
                    'Erro ao criar os ambientes e alocar as vlans do Spine-leaf.'
                )

            # BE - PRODUCAO
            try:
                environment_list = ambiente_prod(user, rack, environment_list)
            except ObjectDoesNotExist, e:
                raise var_exceptions.VariableDoesNotExistException(e)
            except:
                raise RackAplError(None, rack.nome,
                                   'Erro ao criar os ambientes de produção.')

            # BE - Hosts - CLOUD
            try:
                environment_list = ambiente_cloud(user, rack, environment_list)
            except:
                raise RackAplError(
                    None, rack.nome,
                    'Erro ao criar os ambientes e alocar as vlans da Cloud.')

            # FE
            try:
                environment_list = ambiente_prod_fe(user, rack,
                                                    environment_list)
            except ObjectDoesNotExist, e:
                raise var_exceptions.VariableDoesNotExistException(e)
from networkapi.ip.models import Ip
from networkapi.ip.models import IpEquipamento
from networkapi.rack.models import Rack
from networkapi.rack.models import RackConfigError
from networkapi.rack.models import RackError
from networkapi.rack.models import RackNumberNotFoundError
from networkapi.rack.resource.GeraConfig import autoprovision_coreoob
from networkapi.rack.resource.GeraConfig import autoprovision_splf
from networkapi.rest import RestResource
from networkapi.rest import UserNotAuthorizedError
from networkapi.system import exceptions as var_exceptions
from networkapi.system.facade import get_value as get_variable

log = logging.getLogger(__name__)

if int(get_variable('use_foreman')):
    from foreman.client import Foreman, ForemanException


def buscar_roteiro(id_sw, tipo):

    roteiros = EquipamentoRoteiro.search(None, id_sw)
    for rot in roteiros:
        if (rot.roteiro.tipo_roteiro.tipo == tipo):
            roteiro_eq = rot.roteiro.roteiro
    roteiro_eq = roteiro_eq.lower()
    if '.txt' not in roteiro_eq:
        roteiro_eq = roteiro_eq + '.txt'

    return roteiro_eq
    def handle_post(self, request, user, *args, **kwargs):
        """Treat requests POST to create the configuration file.

        URL: rack/alocar-config/id_rack
        """
        try:

            # 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)

            #Validar configuracao
            if not rack.config:
                raise RackAplError(None, rack.nome, "Os arquivos de configuracao devem ser gerados antes.")

            if rack.create_vlan_amb:
                raise RackAplError(None, rack.nome, "As vlans, redes e ambientes ja foram criados.")

            #variaveis
            name_core1, name_core2 =  get_core_name(rack)

            environment_list = []

            variablestochangecore1 = {}
            variablestochangecore2 = {}
            variablestochangecore1 = dic_vlan_core(variablestochangecore1, rack.numero, name_core1, rack.nome)
            variablestochangecore2 = dic_vlan_core(variablestochangecore2, rack.numero, name_core2, rack.nome)

            #######################################################################           VLAN Gerencia SO
            ambientes=dict()
            try:
                DIVISAODC_MGMT = get_variable("divisaodc_mngt")
                AMBLOG_MGMT = get_variable("amblog_mngt")
                GRPL3_MGMT = get_variable("grpl3_mngt")
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException("Erro buscando as variáveis <DIVISAODC,AMBLOG,GRPL3>_MGMT.")

            ambientes['DC']=DIVISAODC_MGMT
            ambientes['LOG']=AMBLOG_MGMT
            ambientes['L3']=GRPL3_MGMT
    
            try:
                #criar vlan
                vlan = criar_vlan(user, variablestochangecore1, ambientes)
            except:
                raise RackAplError(None, rack.nome, "Erro ao criar a VLAN_SO.")
            try:
                #criar rede
                network = criar_rede(user, "Rede invalida equipamentos", variablestochangecore1, vlan)
            except:
                raise RackAplError(None, rack.nome, "Erro ao criar a rede da VLAN_SO")
            try:
                #inserir os Core
                inserir_equip(user, variablestochangecore1, network.id)           
                inserir_equip(user, variablestochangecore2, network.id)            
            except:
                raise RackAplError(None, rack.nome, "Erro ao inserir o core 1 e 2")
                
            #######################################################################                   Ambientes

            #BE - SPINE - LEAF
            try:
                environment_list = ambiente_spn_lf(user, rack, environment_list)
            except:
                raise RackAplError(None, rack.nome, "Erro ao criar os ambientes e alocar as vlans do Spine-leaf.")

            #BE - PRODUCAO
            try:
                environment_list = ambiente_prod(user, rack, environment_list)
            except ObjectDoesNotExist, e:
                raise var_exceptions.VariableDoesNotExistException(e)
            except:
                raise RackAplError(None, rack.nome, "Erro ao criar os ambientes de produção.")

            #BE - Hosts - CLOUD
            try:
                environment_list = ambiente_cloud(user, rack, environment_list)
            except:
                raise RackAplError(None, rack.nome, "Erro ao criar os ambientes e alocar as vlans da Cloud.")

            #FE
            try:
                environment_list = ambiente_prod_fe(user, rack, environment_list)
            except ObjectDoesNotExist, e:
                raise var_exceptions.VariableDoesNotExistException(e)
def gera_config(rack):

    id_core1=None
    id_core2=None
    name_sp1=None
    name_sp2=None   
    name_sp3=None   
    name_sp4=None   
    name_core1=None
    name_core2=None
    int_sp1=None
    int_sp2=None   
    int_sp3=None   
    int_sp4=None   
    int_lf1_sp1=None   
    int_lf1_sp2=None   
    int_lf2_sp3=None   
    int_lf2_sp4=None
    int_oob_mgmtlf1=None
    int_oob_mgmtlf2=None
    int_oob_core1=None  
    int_oob_core2=None  
    int_core1_oob=None  
    int_core2_oob=None  


    #Equipamentos
    num_rack = rack.numero
    try:
        id_lf1 = rack.id_sw1.id
        name_lf1 = rack.id_sw1.nome
        id_lf2 = rack.id_sw2.id
        name_lf2 = rack.id_sw2.nome
        id_oob = rack.id_ilo.id
        name_oob = rack.id_ilo.nome
    except:
        raise RackConfigError(None,rack.nome,"Erro: Rack incompleto.")


    #Interface leaf01
    try:
        interfaces = Interface.search(id_lf1)
        for interface in interfaces:
            try: 
                sw = interface.get_switch_and_router_interface_from_host_interface(None)
                if sw.equipamento.nome.split('-')[2]=='01' or sw.equipamento.nome.split('-')[2]=='1': 
                    int_lf1_sp1 = interface.interface
                    name_sp1 = sw.equipamento.nome
                    id_sp1 = sw.equipamento.id
                    int_sp1 =  sw.interface
                elif sw.equipamento.nome.split('-')[2]=='02' or sw.equipamento.nome.split('-')[2]=='2':
                    int_lf1_sp2 = interface.interface
                    name_sp2 = sw.equipamento.nome
                    id_sp2 = sw.equipamento.id
                    int_sp2 =  sw.interface 
                elif sw.equipamento.nome.split('-')[0]=='OOB':
                    int_oob_mgmtlf1 = sw.interface
            except:
                pass
    except InterfaceNotFoundError:
        raise RackConfigError(None,rack.nome,"Erro ao buscar as interfaces associadas ao Leaf 01.")

    if int_sp1==None or int_sp2==None or int_oob_mgmtlf1==None:
        raise RackConfigError(None,rack.nome,"Erro: As interfaces do Leaf01 nao foram cadastradas.")  

    #Interface leaf02
    try:
        interfaces1 = Interface.search(id_lf2)
        for interface1 in interfaces1:
            try:
                sw = interface1.get_switch_and_router_interface_from_host_interface(None)
                if sw.equipamento.nome.split('-')[2]=='03' or sw.equipamento.nome.split('-')[2]=='3':
                    int_lf2_sp3 = interface1.interface
                    name_sp3 = sw.equipamento.nome
                    id_sp3 = sw.equipamento.id
                    int_sp3 =  sw.interface
                elif sw.equipamento.nome.split('-')[2]=='04' or sw.equipamento.nome.split('-')[2]=='4':
                    int_lf2_sp4 = interface1.interface
                    name_sp4 = sw.equipamento.nome
                    id_sp4 = sw.equipamento.id
                    int_sp4 =  sw.interface
                elif sw.equipamento.nome.split('-')[0]=='OOB':
                    int_oob_mgmtlf2 = sw.interface
            except:
                pass
    except InterfaceNotFoundError:
        raise RackConfigError(None,rack.nome,"Erro ao buscar as interfaces associadas ao Leaf 02.")

    if int_sp3==None or int_sp4==None or int_oob_mgmtlf2==None:
        raise RackConfigError(None,rack.nome,"Erro: As interfaces do Leaf02 nao foram cadastradas.")

    #Interface OOB
    try:
        interfaces2 = Interface.search(id_oob)
        for interface2 in interfaces2:
            try:
                sw = interface2.get_switch_and_router_interface_from_host_interface(None)
                if sw.equipamento.nome.split('-')[0]=='OOB':
                    if sw.equipamento.nome.split('-')[2]=='01' or sw.equipamento.nome.split('-')[2]=='1':
                        int_oob_core1 = interface2.interface
                        name_core1 = sw.equipamento.nome
                        int_core1_oob =  sw.interface
                        id_core1 = sw.equipamento.id
                    elif sw.equipamento.nome.split('-')[2]=='02' or sw.equipamento.nome.split('-')[2]=='2':
                        int_oob_core2 = interface2.interface
                        name_core2 = sw.equipamento.nome
                        int_core2_oob =  sw.interface
                        id_core2 = sw.equipamento.id
            except:
                pass 
    except InterfaceNotFoundError:
        raise RackConfigError(None,rack.nome,"Erro ao buscar as interfaces associadas ao Switch de gerencia.")

    if int_oob_core1==None or int_core1_oob==None or int_oob_core2==None or int_core2_oob==None:
        raise RackConfigError(None,rack.nome,"Erro: As interfaces do Switch de gerencia nao foram cadastradas.")

    #Roteiro LF01
    try:
        FILEINLF1 = buscar_roteiro(id_lf1, "CONFIGURACAO")
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Leaf 01.")

   #Roteiro LF02
    try:
        FILEINLF2 = buscar_roteiro(id_lf2, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Leaf 02.")

    #Roteiro SPN01
    try:
        FILEINSP1 = buscar_roteiro(id_sp1, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Spine 01.")

    #Roteiro SPN02
    try:
        FILEINSP2 = buscar_roteiro(id_sp2, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Spine 02.")

    #Roteiro SPN03
    try:
        FILEINSP3 = buscar_roteiro(id_sp3, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Spine 03.")

    #Roteiro SPN04
    try:
        FILEINSP4 = buscar_roteiro(id_sp4, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Spine 04.")

    #Roteiro Core 01
    try:
        FILEINCR1 = buscar_roteiro(id_core1, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Core 01.")

    #Roteiro Core 02
    try:
        FILEINCR2 = buscar_roteiro(id_core2, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do Core 02.")

    #Roteiro OOB
    try:
        FILEINOOB = buscar_roteiro(id_oob, "CONFIGURACAO")    
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o roteiro do switch de gerencia.")

    #Ip LF01
    try:
        ip_mgmtlf1 = buscar_ip(id_lf1)
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o ip de gerencia do leaf 01.")

    #Ip LF02
    try:
        ip_mgmtlf2 = buscar_ip(id_lf2)
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o ip de gerencia do leaf 02.")

    #Ip OOB
    try:
        ip_mgmtoob = buscar_ip(id_oob)
    except:
        raise RackConfigError(None,rack.nome,"Erro ao buscar o ip de gerencia do oob.")

    try:
        NETWORKAPI_USE_FOREMAN = int(get_variable("use_foreman"))
        NETWORKAPI_FOREMAN_URL = get_variable("foreman_url")
        NETWORKAPI_FOREMAN_USERNAME = get_variable("foreman_username")
        NETWORKAPI_FOREMAN_PASSWORD = get_variable("foreman_password")
        FOREMAN_HOSTS_ENVIRONMENT_ID = get_variable("foreman_hosts_environment_id")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando as variáveis relativas ao Foreman.")

    #begin - Create Foreman entries for rack switches
    if NETWORKAPI_USE_FOREMAN:
        foreman = Foreman(NETWORKAPI_FOREMAN_URL, (NETWORKAPI_FOREMAN_USERNAME, NETWORKAPI_FOREMAN_PASSWORD), api_version=2)

        #for each switch, check the switch ip against foreman know networks, finds foreman hostgroup
        # based on model and brand and inserts the host in foreman
        # if host already exists, delete and recreate with new information
        for [switch, mac] in [[rack.id_sw1, rack.mac_sw1], [rack.id_sw2, rack.mac_sw2], [rack.id_ilo, rack.mac_ilo]]:
            #Get all foremand subnets and compare with the IP address of the switches until find it
            if mac == None:
                raise RackConfigError(None, rack.nome, ("Could not create entry for %s. There is no mac address." % (switch.nome)))

            ip = buscar_ip(switch.id)
            switch_cadastrado=0
            for subnet in foreman.subnets.index()['results']:
                network = IPNetwork(ip+'/'+subnet['mask']).network
                #check if switches ip network is the same as subnet['subnet']['network'] e subnet['subnet']['mask']
                if network.__str__() == subnet['network']:
                    subnet_id = subnet['id']
                    hosts = foreman.hosts.index(search=switch.nome)['results']
                    if len(hosts) == 1:
                        foreman.hosts.destroy(id=hosts[0]['id'])
                    elif len(hosts) > 1:
                        raise RackConfigError(None, rack.nome, ("Could not create entry for %s. There are multiple entries with the sam name." % (switch.nome)))

                    #Lookup foreman hostgroup
                    #By definition, hostgroup should be Marca+"_"+Modelo
                    hostgroup_name = switch.modelo.marca.nome+"_"+switch.modelo.nome
                    hostgroups = foreman.hostgroups.index(search=hostgroup_name)
                    if len(hostgroups['results']) == 0:
                        raise RackConfigError(None, rack.nome, "Could not create entry for %s. Could not find hostgroup %s in foreman." % (switch.nome, hostgroup_name))
                    elif len(hostgroups['results'])>1:
                        raise RackConfigError(None, rack.nome, "Could not create entry for %s. Multiple hostgroups %s found in Foreman." % (switch.nome, hostgroup_name))
                    else:
                        hostgroup_id = hostgroups['results'][0]['id']

                    host = foreman.hosts.create(host={'name': switch.nome, 'ip': ip, 'mac': mac, 'environment_id': FOREMAN_HOSTS_ENVIRONMENT_ID, 'hostgroup_id': hostgroup_id, 'subnet_id': subnet_id, 'build': 'true', 'overwrite': 'true'})
                    switch_cadastrado=1
                    
            if not switch_cadastrado:
                raise RackConfigError(None, rack.nome, "Unknown error. Could not create entry for %s in foreman." % (switch.nome))
    #end - Create Foreman entries for rack switches
    var1 = autoprovision_splf(num_rack, FILEINLF1, FILEINLF2, FILEINSP1, FILEINSP2, FILEINSP3, FILEINSP4, name_lf1, name_lf2, name_oob, name_sp1, name_sp2, name_sp3, name_sp4, ip_mgmtlf1, ip_mgmtlf2, int_oob_mgmtlf1, int_oob_mgmtlf2, int_sp1, int_sp2, int_sp3, int_sp4, int_lf1_sp1, int_lf1_sp2, int_lf2_sp3, int_lf2_sp4)

    var2 = autoprovision_coreoob(num_rack, FILEINCR1, FILEINCR2, FILEINOOB, name_core1, name_core2, name_oob, name_lf1, name_lf2, ip_mgmtoob, int_oob_core1, int_oob_core2, int_core1_oob, int_core2_oob )

    if var1 and var2:
        return True

    return False
示例#46
0
def autoprovision_splf(rack,FILEINLF1, FILEINLF2,FILEINSP1, FILEINSP2, FILEINSP3, FILEINSP4,name_lf1, name_lf2, name_oob, name_sp1, name_sp2, name_sp3, name_sp4, ip_mgmtlf1, ip_mgmtlf2, int_oob_mgmtlf1, int_oob_mgmtlf2, int_sp1, int_sp2, int_sp3, int_sp4, int_lf1_sp1,int_lf1_sp2,int_lf2_sp3,int_lf2_sp4):

    # STRUCTURE: IPSPINE[rack][spine]: ip a configurar no spine 'spine' relativo à leaf do rack 'rack'
    # STRUCTURE: IPLEAF[rack][spine]: ip a configurar na leaf do rack 'rack' relativo ao spine 'spine'
    CIDREBGP = {}
    CIDRBE = {}
    IPSPINEipv4 = {}
    IPSPINEipv6 = {}
    IPLEAFipv4 = {}
    IPLEAFipv6 = {}
    IPSIBGPipv4 = {}
    IPSIBGPipv6 = {}
    ASLEAF = {}
    #
    VLANBELEAF = {}
    VLANFELEAF = {}
    VLANBORDALEAF = {}
    VLANBORDACACHOSLEAF = {}
    #
    PODSBEipv4 = {}
    redesPODSBEipv4 = {}
    #
    subnetsRackBEipv4 = {}
    #
    PODSBEipv6 = {}
    redesPODSBEipv6 = {}
    PODSBEFEipv6 = {}
    redesPODSBEFEipv6 = {}
    PODSBEBOipv6 = {}
    redesPODSBEBOipv6 = {}
    PODSBECAipv6 = {}
    redesPODSBECAipv6 = {}
    redesHostsipv6 = {}
    redeHostsBEipv6 = {}
    redeHostsFEipv6 = {}
    redeHostsBOipv6 = {}
    redeHostsCAipv6 = {}
    redeHostsFILERipv6 = {}
    subnetsRackBEipv6 = {}
    subnetsRackFEipv4 = {}
    redesPODSFEipv4 = {}
    subnetsRackFEipv6 = {}
    redesPODSFEipv6 = {}
    #
    IPSPINEipv4[rack]=[]
    IPSPINEipv6[rack]=[]
    IPLEAFipv4[rack]=[]
    IPLEAFipv6[rack]=[]
    IPSIBGPipv4[rack]=[]
    IPSIBGPipv6[rack]=[]
    VLANBELEAF[rack]=[]
    VLANFELEAF[rack]=[]
    VLANBORDALEAF[rack]=[]
    VLANBORDACACHOSLEAF[rack]=[]
    ASLEAF[rack]=[]
    #
    PODSBEipv4[rack]=[]
    redesPODSBEipv4[rack]=[]
    #
    subnetsRackBEipv4[rack] = []
    #
    PODSBEipv6[rack]=[]
    redesPODSBEipv6[rack]=[]
    PODSBEFEipv6[rack]=[]
    redesPODSBEFEipv6[rack]=[]
    PODSBEBOipv6[rack]=[]
    redesPODSBEBOipv6[rack]=[]
    PODSBECAipv6[rack]=[]
    redesPODSBECAipv6[rack]=[]
    redesHostsipv6[rack]=[]
    redeHostsBEipv6[rack]=[]
    redeHostsFEipv6[rack]=[]
    redeHostsBOipv6[rack]=[]
    redeHostsCAipv6[rack]=[]
    redeHostsFILERipv6[rack]=[]
    subnetsRackBEipv6[rack] = []
    subnetsRackFEipv4[rack] = []
    redesPODSFEipv4[rack] = []
    subnetsRackFEipv6[rack] = []
    redesPODSFEipv6[rack] = []

    CIDRFEipv4 = {}
    CIDRFEipv6 = {}

    variablestochangespine1={}
    variablestochangespine2={}
    variablestochangespine3={}
    variablestochangespine4={}
    variablestochangeleaf1={}
    variablestochangeleaf2={}

    try:
        fileinleaf1=get_variable("path_to_guide")+FILEINLF1
        fileinleaf2=get_variable("path_to_guide")+FILEINLF2
        fileinspine1=get_variable("path_to_guide")+FILEINSP1
        fileinspine2=get_variable("path_to_guide")+FILEINSP2
        fileinspine3=get_variable("path_to_guide")+FILEINSP3
        fileinspine4=get_variable("path_to_guide")+FILEINSP4
        BASE_RACK = int(get_variable("base_rack"))
        BASE_AS = int(get_variable("base_as"))
        VLANBE = int(get_variable("vlanbe"))
        VLANFE = int(get_variable("vlanfe"))
        VLANBORDA = int(get_variable("vlanborda"))
        VLANBORDACACHOS = int(get_variable("vlanbordacachos"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável PATH_TO_GUIDE ou BASE_<RACK,AS> ou VLAN<BE,FE,BORDA,CACHOS>.")
示例#47
0
import logging
from networkapi.rest import RestResource, UserNotAuthorizedError
from networkapi.equipamento.models import EquipamentoRoteiro
from networkapi.interface.models import Interface, InterfaceNotFoundError
from networkapi.rack.resource.GeraConfig import autoprovision_splf, autoprovision_coreoob
from networkapi.ip.models import Ip, IpEquipamento
from netaddr import IPNetwork
from requests.exceptions import RequestException
from networkapi.system.facade import get_value as get_variable
from networkapi.system import exceptions as var_exceptions
from django.core.exceptions import ObjectDoesNotExist
import re

log = logging.getLogger(__name__)

if int(get_variable("use_foreman")):
    from foreman.client import Foreman, ForemanException


def buscar_roteiro(id_sw, tipo):

    roteiros = EquipamentoRoteiro.search(None, id_sw)
    for rot in roteiros:
        if (rot.roteiro.tipo_roteiro.tipo == tipo):
            roteiro_eq = rot.roteiro.roteiro
    roteiro_eq = roteiro_eq.lower()
    if not '.txt' in roteiro_eq:
        roteiro_eq = roteiro_eq + ".txt"

    return roteiro_eq
示例#48
0
def gera_config(rack):

    id_core1 = None
    id_core2 = None
    name_sp1 = None
    name_sp2 = None
    name_sp3 = None
    name_sp4 = None
    name_core1 = None
    name_core2 = None
    int_sp1 = None
    int_sp2 = None
    int_sp3 = None
    int_sp4 = None
    int_lf1_sp1 = None
    int_lf1_sp2 = None
    int_lf2_sp3 = None
    int_lf2_sp4 = None
    int_oob_mgmtlf1 = None
    int_oob_mgmtlf2 = None
    int_oob_core1 = None
    int_oob_core2 = None
    int_core1_oob = None
    int_core2_oob = None
    prefix_spine = 'SPN'
    prefix_oob = 'OOB'

    # Equipamentos
    num_rack = rack.numero
    try:
        id_lf1 = rack.id_sw1.id
        name_lf1 = rack.id_sw1.nome
        id_lf2 = rack.id_sw2.id
        name_lf2 = rack.id_sw2.nome
        id_oob = rack.id_ilo.id
        name_oob = rack.id_ilo.nome
    except:
        raise RackConfigError(None, rack.nome, 'Erro: Rack incompleto.')

    # Interface leaf01
    try:
        interfaces = Interface.search(id_lf1)
        for interface in interfaces:
            try:
                sw = interface.get_switch_and_router_interface_from_host_interface(
                    None)
                if sw.equipamento.nome.split('-')[0] == prefix_spine:
                    if sw.equipamento.nome.split('-')[2] == '01' or sw.equipamento.nome.split('-')[2] == '1':
                        int_lf1_sp1 = interface.interface
                        name_sp1 = sw.equipamento.nome
                        id_sp1 = sw.equipamento.id
                        int_sp1 = sw.interface
                    elif sw.equipamento.nome.split('-')[2] == '02' or sw.equipamento.nome.split('-')[2] == '2':
                        int_lf1_sp2 = interface.interface
                        name_sp2 = sw.equipamento.nome
                        id_sp2 = sw.equipamento.id
                        int_sp2 = sw.interface
                elif sw.equipamento.nome.split('-')[0] == prefix_oob:
                    int_oob_mgmtlf1 = sw.interface
            except:
                pass
    except InterfaceNotFoundError:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar as interfaces associadas ao Leaf 01.')

    if int_sp1 is None or int_sp2 is None or int_oob_mgmtlf1 is None:
        raise RackConfigError(
            None, rack.nome, 'Erro: As interfaces do Leaf01 nao foram cadastradas.')

    # Interface leaf02
    try:
        interfaces1 = Interface.search(id_lf2)
        for interface1 in interfaces1:
            try:
                sw = interface1.get_switch_and_router_interface_from_host_interface(
                    None)
                if sw.equipamento.nome.split('-')[0] == prefix_spine:
                    if sw.equipamento.nome.split('-')[2] == '03' or sw.equipamento.nome.split('-')[2] == '3':
                        int_lf2_sp3 = interface1.interface
                        name_sp3 = sw.equipamento.nome
                        id_sp3 = sw.equipamento.id
                        int_sp3 = sw.interface
                    elif sw.equipamento.nome.split('-')[2] == '04' or sw.equipamento.nome.split('-')[2] == '4':
                        int_lf2_sp4 = interface1.interface
                        name_sp4 = sw.equipamento.nome
                        id_sp4 = sw.equipamento.id
                        int_sp4 = sw.interface
                elif sw.equipamento.nome.split('-')[0] == prefix_oob:
                    int_oob_mgmtlf2 = sw.interface
            except:
                pass
    except InterfaceNotFoundError:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar as interfaces associadas ao Leaf 02.')

    if int_sp3 is None or int_sp4 is None or int_oob_mgmtlf2 is None:
        raise RackConfigError(
            None, rack.nome, 'Erro: As interfaces do Leaf02 nao foram cadastradas.')

    # Interface OOB
    try:
        interfaces2 = Interface.search(id_oob)
        for interface2 in interfaces2:
            try:
                sw = interface2.get_switch_and_router_interface_from_host_interface(
                    None)
                if sw.equipamento.nome.split('-')[0] == prefix_oob:
                    if sw.equipamento.nome.split('-')[2] == '01' or sw.equipamento.nome.split('-')[2] == '1':
                        int_oob_core1 = interface2.interface
                        name_core1 = sw.equipamento.nome
                        int_core1_oob = sw.interface
                        id_core1 = sw.equipamento.id
                    elif sw.equipamento.nome.split('-')[2] == '02' or sw.equipamento.nome.split('-')[2] == '2':
                        int_oob_core2 = interface2.interface
                        name_core2 = sw.equipamento.nome
                        int_core2_oob = sw.interface
                        id_core2 = sw.equipamento.id
            except:
                pass
    except InterfaceNotFoundError:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar as interfaces associadas ao Switch de gerencia.')

    if int_oob_core1 is None or int_core1_oob is None or int_oob_core2 is None or int_core2_oob is None:
        raise RackConfigError(
            None, rack.nome, 'Erro: As interfaces do Switch de gerencia nao foram cadastradas.')

    # Roteiro LF01
    try:
        FILEINLF1 = buscar_roteiro(id_lf1, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Leaf 01.')

    # Roteiro LF02
    try:
        FILEINLF2 = buscar_roteiro(id_lf2, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Leaf 02.')

    # Roteiro SPN01
    try:
        FILEINSP1 = buscar_roteiro(id_sp1, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Spine 01.')

    # Roteiro SPN02
    try:
        FILEINSP2 = buscar_roteiro(id_sp2, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Spine 02.')

    # Roteiro SPN03
    try:
        FILEINSP3 = buscar_roteiro(id_sp3, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Spine 03.')

    # Roteiro SPN04
    try:
        FILEINSP4 = buscar_roteiro(id_sp4, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Spine 04.')

    # Roteiro Core 01
    try:
        FILEINCR1 = buscar_roteiro(id_core1, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Core 01.')

    # Roteiro Core 02
    try:
        FILEINCR2 = buscar_roteiro(id_core2, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do Core 02.')

    # Roteiro OOB
    try:
        FILEINOOB = buscar_roteiro(id_oob, 'CONFIGURACAO')
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o roteiro do switch de gerencia.')

    # Ip LF01
    try:
        ip_mgmtlf1 = buscar_ip(id_lf1)
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o ip de gerencia do leaf 01.')

    # Ip LF02
    try:
        ip_mgmtlf2 = buscar_ip(id_lf2)
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o ip de gerencia do leaf 02.')

    # Ip OOB
    try:
        ip_mgmtoob = buscar_ip(id_oob)
    except:
        raise RackConfigError(
            None, rack.nome, 'Erro ao buscar o ip de gerencia do oob.')

    try:
        NETWORKAPI_USE_FOREMAN = int(get_variable('use_foreman'))
        NETWORKAPI_FOREMAN_URL = get_variable('foreman_url')
        NETWORKAPI_FOREMAN_USERNAME = get_variable('foreman_username')
        NETWORKAPI_FOREMAN_PASSWORD = get_variable('foreman_password')
        FOREMAN_HOSTS_ENVIRONMENT_ID = get_variable(
            'foreman_hosts_environment_id')
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando as variáveis relativas ao Foreman.')

    # begin - Create Foreman entries for rack switches
    if NETWORKAPI_USE_FOREMAN:
        foreman = Foreman(NETWORKAPI_FOREMAN_URL, (NETWORKAPI_FOREMAN_USERNAME,
                                                   NETWORKAPI_FOREMAN_PASSWORD), api_version=2)

        # for each switch, check the switch ip against foreman know networks, finds foreman hostgroup
        # based on model and brand and inserts the host in foreman
        # if host already exists, delete and recreate with new information
        for [switch, mac] in [[rack.id_sw1, rack.mac_sw1], [rack.id_sw2, rack.mac_sw2], [rack.id_ilo, rack.mac_ilo]]:
            # Get all foremand subnets and compare with the IP address of the
            # switches until find it
            if mac is None:
                raise RackConfigError(
                    None, rack.nome, ('Could not create entry for %s. There is no mac address.' % (switch.nome)))

            ip = buscar_ip(switch.id)
            if ip is None:
                raise RackConfigError(
                    None, rack.nome, ('Could not create entry for %s. There is no management IP.' % (switch.nome)))

            switch_cadastrado = 0
            for subnet in foreman.subnets.index()['results']:
                network = IPNetwork(ip + '/' + subnet['mask']).network
                # check if switches ip network is the same as
                # subnet['subnet']['network'] e subnet['subnet']['mask']
                if network.__str__() == subnet['network']:
                    subnet_id = subnet['id']
                    hosts = foreman.hosts.index(search=switch.nome)['results']
                    if len(hosts) == 1:
                        foreman.hosts.destroy(id=hosts[0]['id'])
                    elif len(hosts) > 1:
                        raise RackConfigError(
                            None, rack.nome, ('Could not create entry for %s. There are multiple entries with the sam name.' % (switch.nome)))

                    # Lookup foreman hostgroup
                    # By definition, hostgroup should be Marca+"_"+Modelo
                    hostgroup_name = switch.modelo.marca.nome + '_' + switch.modelo.nome
                    hostgroups = foreman.hostgroups.index(
                        search=hostgroup_name)
                    if len(hostgroups['results']) == 0:
                        raise RackConfigError(None, rack.nome, 'Could not create entry for %s. Could not find hostgroup %s in foreman.' % (
                            switch.nome, hostgroup_name))
                    elif len(hostgroups['results']) > 1:
                        raise RackConfigError(None, rack.nome, 'Could not create entry for %s. Multiple hostgroups %s found in Foreman.' % (
                            switch.nome, hostgroup_name))
                    else:
                        hostgroup_id = hostgroups['results'][0]['id']

                    host = foreman.hosts.create(host={'name': switch.nome, 'ip': ip, 'mac': mac, 'environment_id': FOREMAN_HOSTS_ENVIRONMENT_ID,
                                                      'hostgroup_id': hostgroup_id, 'subnet_id': subnet_id, 'build': 'true', 'overwrite': 'true'})
                    switch_cadastrado = 1

            if not switch_cadastrado:
                raise RackConfigError(None, rack.nome, "Unknown error. Could not create entry for %s in foreman." % (switch.nome))
    #end - Create Foreman entries for rack switches
    var1 = autoprovision_splf(num_rack, FILEINLF1, FILEINLF2, FILEINSP1, FILEINSP2, FILEINSP3, FILEINSP4,
                              name_lf1, name_lf2, name_oob, name_sp1, name_sp2, name_sp3, name_sp4,
                              ip_mgmtlf1, ip_mgmtlf2,
                              int_oob_mgmtlf1, int_oob_mgmtlf2, int_sp1, int_sp2, int_sp3, int_sp4, int_lf1_sp1,
                              int_lf1_sp2, int_lf2_sp3, int_lf2_sp4)

    var2 = autoprovision_coreoob(num_rack, FILEINCR1, FILEINCR2, FILEINOOB,
                                 name_core1, name_core2, name_oob, name_lf1, name_lf2,
                                 ip_mgmtoob, int_oob_core1, int_oob_core2, int_core1_oob, int_core2_oob )


    if var1 and var2:
        return True

    return False
示例#49
0
def ambiente_prod(user, rack, environment_list):

    redes, ipv6 = dic_pods(rack.numero)

    divisao_aclpaths = [['BE', 'BECLOUD'], ['BEFE', 'BEFE'],
                        ['BEBORDA', 'BEBORDA'], ['BECACHOS', 'BECACHOS']]

    grupol3 = rack.nome
    ambiente_logico = 'PRODUCAO'

    ambientes = dict()
    ambientes['LOG'] = ambiente_logico
    ambientes['L3'] = grupol3

    ranges = dict()
    hosts = dict()
    vlans = dict()

    try:
        base_vlan = int(get_variable('num_vlan_acl_be'))
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável  NUM_VLAN_ACL_BE')

    hosts['TIPO'] = 'Rede invalida equipamentos'
    ipv6['TIPO'] = 'Rede invalida equipamentos'

    for item in divisao_aclpaths:
        divisaodc = item[0]
        acl_path = item[1]

        ambientes['DC'] = divisaodc

        # criar ambiente
        vlan_min = divisaodc + '_VLAN_MIN'
        vlan_max = divisaodc + '_VLAN_MAX'
        ranges['MAX'] = redes.get(vlan_max)
        ranges['MIN'] = redes.get(vlan_min)

        env = criar_ambiente(user, ambientes, ranges, acl_path, 'Servidores',
                             'BEVrf')
        environment_list.append(env)

        # configuracao dos ambientes
        prefix = divisaodc + '_PREFIX'
        rede = divisaodc + '_REDE'

        hosts['PREFIX'] = redes.get(prefix)
        hosts['REDE'] = redes.get(rede)
        hosts['VERSION'] = 'ipv4'
        config_ambiente(user, hosts, ambientes)

        ipv6['PREFIX'] = ipv6.get(prefix)
        ipv6['REDE'] = ipv6.get(rede)
        ipv6['VERSION'] = 'ipv6'
        config_ambiente(user, ipv6, ambientes)

        vlans['VLAN_NUM'] = base_vlan
        base_vlan += 1
        vlans['VLAN_NAME'] = 'ACL_' + divisaodc + '_' + ambientes.get('L3')
        criar_vlan(user, vlans, ambientes, 1)

    return environment_list
示例#50
0
        BASE_RACK = int(get_variable('base_rack'))
        VLANBE = int(get_variable('vlanbe'))
        VLANFE = int(get_variable('vlanfe'))
        VLANBORDA = int(get_variable('vlanborda'))
        VLANBORDACACHOS = int(get_variable('vlanbordacachos'))
        VLANBETORxTOR = int(get_variable('vlanbetorxtor'))
        # CIDR sala 01 => 10.128.0.0/12
        CIDRBE[0] = IPNetwork(get_variable('cidr_sl01'))
        CIDREBGP[0] = IPNetwork(get_variable('cidr_bgp'))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável BASE_RACK ou VLAN<BE,FE,BORDA,CACHOS,TORxTOR> ou CIDR<BE,EBGP>.'
        )

    SPINE1ipv4 = IPNetwork(get_variable('net_spn01'))
    SPINE2ipv4 = IPNetwork(get_variable('net_spn02'))
    SPINE3ipv4 = IPNetwork(get_variable('net_spn03'))
    SPINE4ipv4 = IPNetwork(get_variable('net_spn04'))
    # REDE subSPINE1ipv4[rack]
    subSPINE1ipv4 = list(SPINE1ipv4.subnet(31))
    subSPINE2ipv4 = list(SPINE2ipv4.subnet(31))
    subSPINE3ipv4 = list(SPINE3ipv4.subnet(31))
    subSPINE4ipv4 = list(SPINE4ipv4.subnet(31))

    SPINE1ipv6 = IPNetwork(get_variable('net_spn01_v6'))
    SPINE2ipv6 = IPNetwork(get_variable('net_spn02_v6'))
    SPINE3ipv6 = IPNetwork(get_variable('net_spn03_v6'))
    SPINE4ipv6 = IPNetwork(get_variable('net_spn04_v6'))
    subSPINE1ipv6 = list(SPINE1ipv6.subnet(127))
    subSPINE2ipv6 = list(SPINE2ipv6.subnet(127))
示例#51
0
def autoprovision_coreoob(rack, equips):

    log.info("AutoprovisionOOB")

    variablestochangecore1 = dict()
    variablestochangecore2 = dict()
    variablestochangeoob = dict()

    prefixlf = "LF-"
    prefixoob = "OOB"
    vlan_base = None

    dcroom = model_to_dict(rack.dcroom)
    log.debug("type: %s" % str(type(dcroom.get("config"))))
    fabricconfig = dcroom.get("config")

    try:
        fabricconfig = json.loads(fabricconfig)
        log.debug("type -ast: %s" % str(type(fabricconfig)))
    except:
        pass

    try:
        fabricconfig = ast.literal_eval(fabricconfig)
        log.debug("config -ast: %s" % str(fabricconfig))
    except:
        pass

    envconfig = fabricconfig
    BASE_CHANNEL = int(envconfig.get("Channel").get(
        "channel")) if envconfig.get("Channel") else 10

    try:
        path_to_guide = get_variable("path_to_guide")
        path_to_add_config = get_variable("path_to_add_config")
        path_to_config = get_variable("path_to_config")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException(
            "Erro buscando a variável PATH_TO_GUIDE")

    environment = models_env.Ambiente.objects.filter(
        dcroom=rack.dcroom.id,
        father_environment__isnull=True,
        ambiente_logico__nome="GERENCIA",
        divisao_dc__nome="OOB").uniqueResult()
    log.debug("environment: %s " % str(environment))
    log.debug("equips: %s" % str(equips))
    vlan_base = environment.min_num_vlan_1

    for net in environment.configs:
        if net.ip_config.type == "v4":
            redev4 = IPNetwork(str(net.ip_config.subnet))
            prefixv4 = int(net.ip_config.new_prefix)
            subredev4 = list(redev4.subnet(prefixv4))

    if not vlan_base:
        raise Exception(
            "Range de Vlans do ambiente de gerencia do fabric não encontrado.")
    if not subredev4:
        raise Exception("Rede ipv4 do ambiente OOB do fabric não encontrado.")

    vlan_so = str(int(vlan_base) + int(rack.numero))
    variablestochangeoob["VLAN_SO"] = vlan_so

    equips_sorted = sorted(equips, key=operator.itemgetter('sw'))
    oob = equips_sorted[-1]

    variablestochangeoob["OWN_IP_MGMT"] = oob.get("ip_mngt")
    variablestochangeoob["HOSTNAME_OOB"] = oob.get("nome")
    variablestochangeoob["HOSTNAME_RACK"] = rack.nome
    fileinoob = path_to_guide + oob.get("roteiro")
    fileoutoob = path_to_config + oob.get("nome") + ".cfg"

    for equip in oob.get("interfaces"):
        nome = equip.get("nome")
        log.debug(str(nome))
        roteiro = equip.get("roteiro")
        if nome[:3] == prefixlf:
            if nome[-1] == "1":
                variablestochangeoob["HOSTNAME_LF1"] = nome
            else:
                variablestochangeoob["HOSTNAME_LF2"] = nome
        elif nome[:3] == prefixoob:
            intoob = equip.get("eq_interface")
            intcore = equip.get("interface")
            if nome[-1] == "1":
                log.info("oob01")
                log.info(str(nome))
                hostname_core1 = nome
                core = int(hostname_core1.split('-')[-1])
                ip = 124 + core
                variablestochangeoob["INT_OOBC1_UPLINK"] = intoob
                variablestochangeoob["INTERFACE_CORE1"] = intcore
                variablestochangeoob["HOSTNAME_CORE1"] = nome
                variablestochangecore1["INT_OOB_UPLINK"] = intoob
                variablestochangecore1["INTERFACE_CORE"] = intcore
                variablestochangecore1["HOSTNAME_RACK"] = rack.nome
                variablestochangecore1["SO_HOSTNAME_OOB"] = "SO_" + str(
                    rack.nome)
                variablestochangecore1["VLAN_SO"] = vlan_so
                variablestochangecore1['IPCORE'] = str(
                    subredev4[rack.numero][ip])
                variablestochangecore1['IPHSRP'] = str(
                    subredev4[rack.numero][1])
                variablestochangecore1['NUM_CHANNEL'] = str(BASE_CHANNEL +
                                                            int(rack.numero))
                if (1 + int(rack.numero)) % 2 == 0:
                    variablestochangecore1["HSRP_PRIORITY"] = "100"
                else:
                    variablestochangecore1["HSRP_PRIORITY"] = "101"
                fileincore1 = path_to_guide + roteiro
                fileoutcore1 = path_to_add_config + nome + "-ADD-" + str(
                    rack.nome) + ".cfg"
            elif nome[-1] == "2":
                log.info("oob02")
                log.info(str(nome))
                hostname_core2 = nome
                core = int(hostname_core2.split('-')[-1])
                ip = 124 + core
                variablestochangeoob["INT_OOBC2_UPLINK"] = intoob
                variablestochangeoob["INTERFACE_CORE2"] = intcore
                variablestochangeoob["HOSTNAME_CORE2"] = nome
                variablestochangecore2["INT_OOB_UPLINK"] = intoob
                variablestochangecore2["INTERFACE_CORE"] = intcore
                variablestochangecore2["HOSTNAME_RACK"] = rack.nome
                variablestochangecore2["SO_HOSTNAME_OOB"] = "SO_" + str(
                    rack.nome)
                variablestochangecore2["VLAN_SO"] = vlan_so
                variablestochangecore2['IPCORE'] = str(
                    subredev4[rack.numero][ip])
                variablestochangecore2['IPHSRP'] = str(
                    subredev4[rack.numero][1])
                variablestochangecore2['NUM_CHANNEL'] = str(BASE_CHANNEL +
                                                            int(rack.numero))
                if (2 + int(rack.numero)) % 2 == 0:
                    variablestochangecore2["HSRP_PRIORITY"] = "100"
                else:
                    variablestochangecore2["HSRP_PRIORITY"] = "101"
                fileincore2 = path_to_guide + roteiro
                fileoutcore2 = path_to_add_config + nome + "-ADD-" + str(
                    rack.nome) + ".cfg"

    replace(fileincore1, fileoutcore1, variablestochangecore1)
    replace(fileincore2, fileoutcore2, variablestochangecore2)
    replace(fileinoob, fileoutoob, variablestochangeoob)

    return True
示例#52
0
    try:
        BASE_RACK = int(get_variable("base_rack"))
        VLANBE = int(get_variable("vlanbe"))
        VLANFE = int(get_variable("vlanfe"))
        VLANBORDA = int(get_variable("vlanborda"))
        VLANBORDACACHOS = int(get_variable("vlanbordacachos"))
        VLANBETORxTOR = int(get_variable("vlanbetorxtor"))
        #CIDR sala 01 => 10.128.0.0/12
        CIDRBE[0] = IPNetwork(get_variable("cidr_sl01"))
        CIDREBGP[0] = IPNetwork(get_variable("cidr_bgp"))
    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException("Erro buscando a variável BASE_RACK ou VLAN<BE,FE,BORDA,CACHOS,TORxTOR> ou CIDR<BE,EBGP>.")


    SPINE1ipv4 = IPNetwork(get_variable("net_spn01"))
    SPINE2ipv4 = IPNetwork(get_variable("net_spn02"))
    SPINE3ipv4 = IPNetwork(get_variable("net_spn03"))
    SPINE4ipv4 = IPNetwork(get_variable("net_spn04"))
    #REDE subSPINE1ipv4[rack]
    subSPINE1ipv4=list(SPINE1ipv4.subnet(31))
    subSPINE2ipv4=list(SPINE2ipv4.subnet(31))
    subSPINE3ipv4=list(SPINE3ipv4.subnet(31))
    subSPINE4ipv4=list(SPINE4ipv4.subnet(31))

    SPINE1ipv6 = IPNetwork(get_variable("net_spn01_v6"))
    SPINE2ipv6 = IPNetwork(get_variable("net_spn02_v6"))
    SPINE3ipv6 = IPNetwork(get_variable("net_spn03_v6"))
    SPINE4ipv6 = IPNetwork(get_variable("net_spn04_v6"))
    subSPINE1ipv6=list(SPINE1ipv6.subnet(127))
    subSPINE2ipv6=list(SPINE2ipv6.subnet(127))
from networkapi.infrastructure.xml_utils import dumps_networkapi
import logging
from networkapi.rest import RestResource, UserNotAuthorizedError
from networkapi.equipamento.models import EquipamentoRoteiro
from networkapi.interface.models import Interface, InterfaceNotFoundError
from networkapi.rack.resource.GeraConfig import autoprovision_splf, autoprovision_coreoob
from networkapi.ip.models import Ip, IpEquipamento
from netaddr import IPNetwork
from requests.exceptions import RequestException
from networkapi.system.facade import get_value as get_variable
from networkapi.system import exceptions as var_exceptions
from django.core.exceptions import ObjectDoesNotExist

log = logging.getLogger(__name__)

if int(get_variable("use_foreman")):
    from foreman.client import Foreman, ForemanException

def buscar_roteiro(id_sw, tipo):

    roteiros = EquipamentoRoteiro.search(None, id_sw)
    for rot in roteiros:
        if (rot.roteiro.tipo_roteiro.tipo==tipo): 
            roteiro_eq = rot.roteiro.roteiro
    roteiro_eq = roteiro_eq.lower()
    if not '.txt' in roteiro_eq:
        roteiro_eq=roteiro_eq+".txt"
        
    return roteiro_eq 

def buscar_ip(id_sw):
示例#54
0
            raise base_exceptions.CommandErrorException(e)
        else:
            log.info('Connected in hostname:%s' % hostname)
            try:
                self._version = self._channel.System.SystemInfo.get_version()

                if self._version[8:len(self._version)].split('.')[0] <= 10:
                    raise base_exceptions.UnsupportedVersion(
                        'This plugin only supports BIG-IP v11 or above')
                else:
                    if session:
                        log.info('Try get new session')
                        session_cur = self._channel.System.Session.get_session_timeout(
                        )
                        log.info('Session Timeout Current: %s' % session_cur)
                        session_timeout = get_variable(
                            'set_session_timeout_plugin_f5', '60')
                        if int(session_cur) > int(session_timeout):
                            self._channel.System.Session.set_session_timeout(
                                session_timeout)
                        self._channel = self.get_session()
            except Exception, e:
                log.error(e)
                raise base_exceptions.CommandErrorException(e)

    def get_session(self):

        try:
            channel = self._channel.with_session_id()
            log.info('Session %s', channel)
        except Exception, e:
            if 'There are too many existing user sessions.'.lower() in str(
    def handle_delete(self, request, user, *args, **kwargs):
        """Treat requests POST to delete Rack.

        URL: rack/id_rack/
        """
        try:
            self.log.info("Delete Rack")

            ########################################################                                     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)

            ######################################################## Mover os arquivos de configuracao que foram gerados
            try:
                LEAF = get_variable("leaf")
                OOB = get_variable("oob")
                SPN = get_variable("spn")
                FORMATO = get_variable("formato")
                PATH_TO_CONFIG = get_variable("path_to_config")
                PATH_TO_MV = get_variable("path_to_mv")
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException("Erro buscando as variáveis <LEAF,OOB,SPN> ou FORMATO ou PATH_TO_<MV,CONFIG>.")

            try:
                for i in range(1,3):
                    nome_lf = LEAF+"-"+rack.nome+"-0"+str(i)+FORMATO
                    nome_lf_b = PATH_TO_CONFIG+nome_lf
                    nome_lf_a = PATH_TO_MV+nome_lf
                    shutil.move(nome_lf_b, nome_lf_a)
                    nome_oob = OOB+"-0"+str(i)+"-ADD-"+rack.nome+FORMATO
                    nome_oob_b = PATH_TO_CONFIG+nome_oob
                    nome_oob_a = PATH_TO_MV+nome_oob
                    shutil.move(nome_oob_b, nome_oob_a)
                for i in range(1,5):
                    nome_spn = SPN+"-0"+str(i)+"-ADD-"+rack.nome+FORMATO
                    nome_spn_b = PATH_TO_CONFIG+nome_spn
                    nome_spn_a = PATH_TO_MV+nome_spn
                    shutil.move(nome_spn_b, nome_spn_a)

                nome_oob = OOB+"-"+rack.nome+"-01"+FORMATO
                nome_oob_b = PATH_TO_CONFIG+nome_oob
                nome_oob_a = PATH_TO_MV+nome_oob
                shutil.move(nome_oob_b, nome_oob_a)
            except:
                pass

            ########################################################                 Remover as Vlans, redes e ambientes
            try:
                desativar_vlan_rede(user, rack)
                lista_amb = remover_ambiente_rack(user, rack)
                remover_ambiente(user, lista_amb, rack)
                remover_vlan_so(user, rack)
            except:
                raise RackError(None, u'Failed to remove the Vlans and Environments.')

            ########################################################         Remove rack config from spines and core oob
            #aplicar(rack)

            ########################################################                                         Remove Rack
            with distributedlock(LOCK_RACK % rack_id):

                try:
                    rack.delete()
                except RackNumberNotFoundError, e:
                    raise e
                except Exception, e:
                    self.log.error(u'Failed to remove the Rack.')
                    raise RackError(e, u'Failed to remove the Rack.')                   
    def handle_delete(self, request, user, *args, **kwargs):
        """Treat requests POST to delete Rack.

        URL: rack/id_rack/
        """
        try:
            self.log.info('Delete Rack')

            # 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)

            # Mover os arquivos de configuracao que foram gerados
            try:
                LEAF = get_variable('leaf')
                OOB = get_variable('oob')
                SPN = get_variable('spn')
                FORMATO = get_variable('formato')
                PATH_TO_CONFIG = get_variable('path_to_config')
                PATH_TO_MV = get_variable('path_to_mv')
            except ObjectDoesNotExist:
                raise var_exceptions.VariableDoesNotExistException(
                    'Erro buscando as variáveis <LEAF,OOB,SPN> ou FORMATO ou PATH_TO_<MV,CONFIG>.'
                )

            try:
                for i in range(1, 3):
                    nome_lf = LEAF + '-' + rack.nome + '-0' + str(i) + FORMATO
                    nome_lf_b = PATH_TO_CONFIG + nome_lf
                    nome_lf_a = PATH_TO_MV + nome_lf
                    shutil.move(nome_lf_b, nome_lf_a)
                    nome_oob = OOB + '-0' + \
                        str(i) + '-ADD-' + rack.nome + FORMATO
                    nome_oob_b = PATH_TO_CONFIG + nome_oob
                    nome_oob_a = PATH_TO_MV + nome_oob
                    shutil.move(nome_oob_b, nome_oob_a)
                for i in range(1, 5):
                    nome_spn = SPN + '-0' + \
                        str(i) + '-ADD-' + rack.nome + FORMATO
                    nome_spn_b = PATH_TO_CONFIG + nome_spn
                    nome_spn_a = PATH_TO_MV + nome_spn
                    shutil.move(nome_spn_b, nome_spn_a)

                nome_oob = OOB + '-' + rack.nome + '-01' + FORMATO
                nome_oob_b = PATH_TO_CONFIG + nome_oob
                nome_oob_a = PATH_TO_MV + nome_oob
                shutil.move(nome_oob_b, nome_oob_a)
            except:
                pass

            # Remover as Vlans, redes e ambientes
            try:
                desativar_vlan_rede(user, rack)
                lista_amb = remover_ambiente_rack(user, rack)
                remover_ambiente(user, lista_amb, rack)
                remover_vlan_so(user, rack)
            except:
                raise RackError(
                    None, u'Failed to remove the Vlans and Environments.')

            # Remove rack config from spines and core oob
            # aplicar(rack)

            # Remove Rack

            with distributedlock(LOCK_RACK % rack_id):
                try:
                    rack.delete()
                except RackNumberNotFoundError, e:
                    raise e
                except Exception, e:
                    self.log.error(u'Failed to remove the Rack.')
                    raise RackError(e, u'Failed to remove the Rack.')
示例#57
0
def autoprovision_splf(rack, FILEINLF1, FILEINLF2, FILEINSP1, FILEINSP2,
                       FILEINSP3, FILEINSP4, name_lf1, name_lf2, name_oob,
                       name_sp1, name_sp2, name_sp3, name_sp4, ip_mgmtlf1,
                       ip_mgmtlf2, int_oob_mgmtlf1, int_oob_mgmtlf2, int_sp1,
                       int_sp2, int_sp3, int_sp4, int_lf1_sp1, int_lf1_sp2,
                       int_lf2_sp3, int_lf2_sp4):

    # STRUCTURE: IPSPINE[rack][spine]: ip a configurar no spine 'spine' relativo à leaf do rack 'rack'
    # STRUCTURE: IPLEAF[rack][spine]: ip a configurar no leaf do rack 'rack' relativo ao spine 'spine'

    CIDREBGP = {}
    CIDRBE = {}
    IPSPINEipv4 = {}
    IPSPINEipv6 = {}
    IPLEAFipv4 = {}
    IPLEAFipv6 = {}
    IPSIBGPipv4 = {}
    IPSIBGPipv6 = {}
    ASLEAF = {}
    #
    VLANBELEAF = {}
    VLANFELEAF = {}
    VLANBORDALEAF = {}
    VLANBORDACACHOSLEAF = {}
    #
    PODSBEipv4 = {}
    redesPODSBEipv4 = {}
    #
    subnetsRackBEipv4 = {}
    #
    PODSBEipv6 = {}
    redesPODSBEipv6 = {}
    PODSBEFEipv6 = {}
    redesPODSBEFEipv6 = {}
    PODSBEBOipv6 = {}
    redesPODSBEBOipv6 = {}
    PODSBECAipv6 = {}
    redesPODSBECAipv6 = {}
    redesHostsipv6 = {}
    redeHostsBEipv6 = {}
    redeHostsFEipv6 = {}
    redeHostsBOipv6 = {}
    redeHostsCAipv6 = {}
    redeHostsFILERipv6 = {}
    subnetsRackBEipv6 = {}
    subnetsRackFEipv4 = {}
    redesPODSFEipv4 = {}
    subnetsRackFEipv6 = {}
    redesPODSFEipv6 = {}
    #
    IPSPINEipv4[rack] = []
    IPSPINEipv6[rack] = []
    IPLEAFipv4[rack] = []
    IPLEAFipv6[rack] = []
    IPSIBGPipv4[rack] = []
    IPSIBGPipv6[rack] = []
    VLANBELEAF[rack] = []
    VLANFELEAF[rack] = []
    VLANBORDALEAF[rack] = []
    VLANBORDACACHOSLEAF[rack] = []
    ASLEAF[rack] = []
    #
    PODSBEipv4[rack] = []
    redesPODSBEipv4[rack] = []
    #
    subnetsRackBEipv4[rack] = []
    #
    PODSBEipv6[rack] = []
    redesPODSBEipv6[rack] = []
    PODSBEFEipv6[rack] = []
    redesPODSBEFEipv6[rack] = []
    PODSBEBOipv6[rack] = []
    redesPODSBEBOipv6[rack] = []
    PODSBECAipv6[rack] = []
    redesPODSBECAipv6[rack] = []
    redesHostsipv6[rack] = []
    redeHostsBEipv6[rack] = []
    redeHostsFEipv6[rack] = []
    redeHostsBOipv6[rack] = []
    redeHostsCAipv6[rack] = []
    redeHostsFILERipv6[rack] = []
    subnetsRackBEipv6[rack] = []
    subnetsRackFEipv4[rack] = []
    redesPODSFEipv4[rack] = []
    subnetsRackFEipv6[rack] = []
    redesPODSFEipv6[rack] = []

    CIDRFEipv4 = {}
    CIDRFEipv6 = {}

    variablestochangespine1 = {}
    variablestochangespine2 = {}
    variablestochangespine3 = {}
    variablestochangespine4 = {}
    variablestochangeleaf1 = {}
    variablestochangeleaf2 = {}

    try:
        fileinleaf1 = get_variable("path_to_guide") + FILEINLF1
        fileinleaf2 = get_variable("path_to_guide") + FILEINLF2
        fileinspine1 = get_variable("path_to_guide") + FILEINSP1
        fileinspine2 = get_variable("path_to_guide") + FILEINSP2
        fileinspine3 = get_variable("path_to_guide") + FILEINSP3
        fileinspine4 = get_variable("path_to_guide") + FILEINSP4
        ###
        BASE_RACK = int(get_variable("base_rack"))
        BASE_AS = int(get_variable("base_as"))
        VLANBE = int(get_variable("vlanbe"))
        VLANFE = int(get_variable("vlanfe"))
        VLANBORDA = int(get_variable("vlanborda"))
        VLANBORDACACHOS = int(get_variable("vlanbordacachos"))
        ###

    except ObjectDoesNotExist, exception:
        log.error(exception)
        raise var_exceptions.VariableDoesNotExistException(
            'Erro buscando a variável PATH_TO_GUIDE ou BASE_<RACK,AS> ou VLAN<BE,FE,BORDA,CACHOS>.'
        )
示例#58
0
def api_foreman(rack):


    try:
        NETWORKAPI_FOREMAN_URL = get_variable("foreman_url")
        NETWORKAPI_FOREMAN_USERNAME = get_variable("foreman_username")
        NETWORKAPI_FOREMAN_PASSWORD = get_variable("foreman_password")
        FOREMAN_HOSTS_ENVIRONMENT_ID = get_variable("foreman_hosts_environment_id")
    except ObjectDoesNotExist:
        raise var_exceptions.VariableDoesNotExistException("Erro buscando as variáveis relativas ao Foreman.")

    foreman = Foreman(NETWORKAPI_FOREMAN_URL, (NETWORKAPI_FOREMAN_USERNAME, NETWORKAPI_FOREMAN_PASSWORD), api_version=2)

    # for each switch, check the switch ip against foreman know networks, finds foreman hostgroup
    # based on model and brand and inserts the host in foreman
    # if host already exists, delete and recreate with new information
    for [switch, mac] in [[rack.id_sw1, rack.mac_sw1], [rack.id_sw2, rack.mac_sw2], [rack.id_ilo, rack.mac_ilo]]:
        # Get all foremand subnets and compare with the IP address of the switches until find it
        if mac == None:
            raise RackConfigError(None, rack.nome, ("Could not create entry for %s. There is no mac address." %
                                                    switch.nome))

        ip = _buscar_ip(switch.id)
        if ip == None:
            raise RackConfigError(None, rack.nome, ("Could not create entry for %s. There is no management IP." %
                                                    switch.nome))

        switch_cadastrado = 0
        for subnet in foreman.subnets.index()['results']:
            network = IPNetwork(ip + '/' + subnet['mask']).network
            # check if switches ip network is the same as subnet['subnet']['network'] e subnet['subnet']['mask']
            if network.__str__() == subnet['network']:
                subnet_id = subnet['id']
                hosts = foreman.hosts.index(search = switch.nome)['results']
                if len(hosts) == 1:
                    foreman.hosts.destroy(id = hosts[0]['id'])
                elif len(hosts) > 1:
                    raise RackConfigError(None, rack.nome, ("Could not create entry for %s. There are multiple entries "
                                                            "with the sam name." % switch.nome))

                # Lookup foreman hostgroup
                # By definition, hostgroup should be Marca+"_"+Modelo
                hostgroup_name = switch.modelo.marca.nome + "_" + switch.modelo.nome
                hostgroups = foreman.hostgroups.index(search = hostgroup_name)
                if len(hostgroups['results']) == 0:
                    raise RackConfigError(None, rack.nome, "Could not create entry for %s. Could not find hostgroup %s "
                                                           "in foreman." % (switch.nome, hostgroup_name))
                elif len(hostgroups['results'])>1:
                    raise RackConfigError(None, rack.nome, "Could not create entry for %s. Multiple hostgroups %s found"
                                                           " in Foreman." % (switch.nome, hostgroup_name))
                else:
                    hostgroup_id = hostgroups['results'][0]['id']

                foreman.hosts.create(host = {'name': switch.nome, 'ip': ip, 'mac': mac,
                                            'environment_id': FOREMAN_HOSTS_ENVIRONMENT_ID,
                                            'hostgroup_id': hostgroup_id, 'subnet_id': subnet_id,
                                            'build': 'true', 'overwrite': 'true'})
                switch_cadastrado = 1

        if not switch_cadastrado:
            raise RackConfigError(None, rack.nome, "Unknown error. Could not create entry for %s in foreman." %
                                  switch.nome)