Exemple #1
0
        def inner(*args, **kwargs):
            import os
            from networkapi.log import Log
            basename = os.path.basename(fun.func_code.co_filename)
            log = Log(basename)
            message = "%s:%s: %s is deprecated. Use the new rest API." % (
                basename,
                fun.func_code.co_firstlineno + 1,
                fun.__name__,
            )

            if new_uri:
                message += " Uri to access: %s" % new_uri

            log.warning(message)
            return fun(*args, **kwargs)
def insert_equipment(equipment_map, user):
    '''
    Insere um equipamento e o relacionamento entre equipamento e o grupo.

    @param equipment_map: Map com as chaves: id_grupo, id_tipo_equipamento, id_modelo e nome
    @param user: Usuário autenticado na API.

    @return Em caso de erro retorna a tupla: (código da mensagem de erro, argumento01, argumento02, ...)
            Em caso de sucesso retorna a tupla: (0, <identificador do equipamento_grupo>, <equipamento>)

    @raise InvalidGroupToEquipmentTypeError: Equipamento do grupo “Equipamentos Orquestração” somente poderá ser criado com tipo igual a “Servidor Virtual”.

    @raise EGrupoNotFoundError: Grupo não cadastrado. 

    @raise GrupoError: Falha ao pesquisar o Grupo. 

    @raise TipoEquipamentoNotFoundError: Tipo de equipamento nao cadastrado.

    @raise ModeloNotFoundError: Modelo nao cadastrado.

    @raise EquipamentoNameDuplicatedError: Nome do equipamento duplicado.

    @raise EquipamentoError: Falha ou inserir o equipamento.

    @raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.  

    '''
    log = Log('insert_equipment')

    log.debug('EQUIPAMENTO_MAP: %s', equipment_map)

    equipment = Equipamento()
    equipment.tipo_equipamento = TipoEquipamento()
    equipment.modelo = Modelo()

    group_id = equipment_map.get('id_grupo')
    if not is_valid_int_greater_zero_param(group_id):
        log.error(
            u'The group_id parameter is not a valid value: %s.', group_id)
        raise InvalidValueError(None, 'group_id', group_id)
    else:
        group_id = int(group_id)

    if not has_perm(user,
                    AdminPermission.EQUIPMENT_MANAGEMENT,
                    AdminPermission.WRITE_OPERATION,
                    group_id,
                    None,
                    AdminPermission.EQUIP_WRITE_OPERATION):
        raise UserNotAuthorizedError(
            None, u'Usuário não tem permissão para executar a operação.')

    equipment_type_id = equipment_map.get('id_tipo_equipamento')
    if not is_valid_int_greater_zero_param(equipment_type_id):
        log.error(
            u'The equipment_type_id parameter is not a valid value: %s.', equipment_type_id)
        raise InvalidValueError(None, 'equipment_type_id', equipment_type_id)
    else:
        equipment.tipo_equipamento.id = int(equipment_type_id)

    model_id = equipment_map.get('id_modelo')
    if not is_valid_int_greater_zero_param(model_id):
        log.error(
            u'The model_id parameter is not a valid value: %s.', model_id)
        raise InvalidValueError(None, 'model_id', model_id)
    else:
        equipment.modelo.id = int(model_id)

    name = equipment_map.get('nome')
    if not is_valid_string_minsize(name, 3) or not is_valid_string_maxsize(name, 50):
        log.error(u'The name parameter is not a valid value: %s.', name)
        raise InvalidValueError(None, 'name', name)
    else:
        equipment.nome = name

    #maintenance is a new feature. Check existing value if not defined in request
    #Old calls does not send this field
    maintenance = equipment_map.get('maintenance')
    if maintenance is None:
        maintenance = False
    if not is_valid_boolean_param(maintenance):
        log.error(u'The maintenance parameter is not a valid value: %s.', maintenance)
        raise InvalidValueError(None, 'maintenance', maintenance)
    else:
        equipment.maintenance = maintenance

    equipment_group_id = equipment.create(user, group_id)

    return 0, equipment_group_id, equipment
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework import status
from rest_framework.response import Response

from networkapi.log import Log
from networkapi.api_rest import exceptions as api_exceptions
from networkapi.exception import InvalidValueError, EnvironmentVipNotFoundError
from networkapi.interface.models import InterfaceNotFoundError
from networkapi.api_interface.permissions import Read, Write, DeployConfig
from networkapi.api_interface import exceptions
from networkapi.api_interface import facade



log = Log(__name__)


@api_view(['PUT'])
@permission_classes((IsAuthenticated, DeployConfig))
def deploy_interface_configuration_sync(request, id_interface):
    """
    Deploy interface configuration on equipment(s)
    """

    try:
        data = facade.generate_and_deploy_interface_config_sync(request.user, id_interface)

        return Response(data)

    except exceptions.InvalidIdInterfaceException, exception:
#     LOG_LEVEL = logging.DEBUG
# else:
#     LOG_LEVEL = logging.INFO


LOG_DAYS = 10
LOG_SHOW_SQL = False
LOG_DB_LEVEL = logging.DEBUG if LOG_SHOW_SQL else logging.INFO
LOG_USE_STDOUT = False
LOG_SHOW_TRACEBACK = True

# Inicialização do log
# O primeiro parâmetro informa o nome do arquivo de log a ser gerado.
# O segundo parâmetro é o número de dias que os arquivos ficarão mantidos.
# O terceiro parâmetro é o nível de detalhamento do Log.
Log.init_log(LOG_FILE, LOG_DAYS, LOG_LEVEL, use_stdout=LOG_USE_STDOUT)

if NETWORKAPI_USE_NEWRELIC:
    import newrelic.agent
    config_file_path = os.environ.get('NETWORKAPI_NEW_RELIC_CONFIG')
    if config_file_path is not None:
        newrelic.agent.initialize(config_file_path, os.environ.get('NETWORKAPI_NEW_RELIC_ENV', 'local'))

PROJECT_ROOT_PATH = os.path.dirname(os.path.abspath(__file__))

NETWORKAPI_DATABASE_NAME = os.getenv('NETWORKAPI_DATABASE_NAME', 'networkapi')
NETWORKAPI_DATABASE_USER = os.getenv('NETWORKAPI_DATABASE_USER', 'root')
NETWORKAPI_DATABASE_PASSWORD = os.getenv('NETWORKAPI_DATABASE_PASSWORD', '')
NETWORKAPI_DATABASE_HOST = os.getenv('NETWORKAPI_DATABASE_HOST', 'localhost')
NETWORKAPI_DATABASE_PORT = os.getenv('NETWORKAPI_DATABASE_PORT', '3306')
NETWORKAPI_DATABASE_OPTIONS = os.getenv('NETWORKAPI_DATABASE_OPTIONS', '{"init_command": "SET storage_engine=INNODB"}')
def insert_vip_request(vip_map, user):
    '''Insere uma requisição de VIP.

    @param vip_map: Mapa com os dados da requisição.
    @param user: Usuário autenticado.

    @return: Em caso de sucesso: tupla (0, <requisição de VIP>).
             Em caso de erro: tupla (código da mensagem de erro, argumento01, argumento02, ...)

    @raise IpNotFoundError: IP não cadastrado.

    @raise IpError: Falha ao pesquisar o IP.

    @raise HealthcheckExpectNotFoundError: HealthcheckExpect não cadastrado.

    @raise HealthcheckExpectError: Falha ao pesquisar o HealthcheckExpect.

    @raise InvalidFinalidadeValueError: Finalidade com valor inválido.

    @raise InvalidClienteValueError: Cliente com valor inválido.

    @raise InvalidAmbienteValueError: Ambiente com valor inválido.

    @raise InvalidCacheValueError: Cache com valor inválido.

    @raise InvalidMetodoBalValueError: Valor do método de balanceamento inválido.

    @raise InvalidPersistenciaValueError: Persistencia com valor inválido.

    @raise InvalidHealthcheckTypeValueError: Healthcheck_Type com valor inválido ou inconsistente em relação ao valor do healthcheck_expect.

    @raise InvalidTimeoutValueError: Timeout com valor inválido.

    @raise InvalidHostNameError: Host não cadastrado.

    @raise EquipamentoError: Falha ao pesquisar o equipamento.

    @raise InvalidMaxConValueError: Número máximo de conexões com valor inválido.

    @raise InvalidBalAtivoValueError: Bal_Ativo com valor inválido.

    @raise InvalidTransbordoValueError: Transbordo com valor inválido.

    @raise InvalidServicePortValueError: Porta do Serviço com valor inválido.

    @raise InvalidRealValueError: Valor inválido de um real.

    @raise InvalidHealthcheckValueError: Valor do healthcheck inconsistente em relação ao valor do healthcheck_type.

    @raise RequisicaoVipsError: Falha ao inserir a requisição de VIP.

    @raise UserNotAuthorizedError:
    '''

    log = Log('insert_vip_request')

    if not has_perm(user, AdminPermission.VIPS_REQUEST, AdminPermission.WRITE_OPERATION):
        raise UserNotAuthorizedError(
            None, u'Usuário não tem permissão para executar a operação.')

    ip_id = vip_map.get('id_ip')
    if not is_valid_int_greater_zero_param(ip_id):
        log.error(u'The ip_id parameter is not a valid value: %s.', ip_id)
        raise InvalidValueError(None, 'ip_id', ip_id)
    else:
        ip_id = int(ip_id)

    vip = RequisicaoVips()
    vip.ip = Ip()
    vip.ip.id = ip_id

    # Valid ports
    vip_map, code = vip.valid_values_ports(vip_map)
    if code is not None:
        return code, vip

    # get environmentVip dor validation dynamic heathcheck

    finalidade = vip_map.get('finalidade')
    cliente = vip_map.get('cliente')
    ambiente = vip_map.get('ambiente')

    if not is_valid_string_minsize(finalidade, 3) or not is_valid_string_maxsize(finalidade, 50):
        log.error(u'Finality value is invalid: %s.', finalidade)
        raise InvalidValueError(None, 'finalidade', finalidade)

    if not is_valid_string_minsize(cliente, 3) or not is_valid_string_maxsize(cliente, 50):
        log.error(u'Client value is invalid: %s.', cliente)
        raise InvalidValueError(None, 'cliente', cliente)

    if not is_valid_string_minsize(ambiente, 3) or not is_valid_string_maxsize(ambiente, 50):
        log.error(u'Environment value is invalid: %s.', ambiente)
        raise InvalidValueError(None, 'ambiente', ambiente)

    try:
        environment_vip = EnvironmentVip.get_by_values(
            finalidade, cliente, ambiente)
    except Exception, e:
        raise EnvironmentVipNotFoundError(
            e, 'The fields finality or client or ambiente is None')
def update_vip_request(vip_id, vip_map, user):

    log = Log('update_vip_request')

    if not has_perm(user,
                    AdminPermission.VIPS_REQUEST,
                    AdminPermission.WRITE_OPERATION):
        raise UserNotAuthorizedError(
            None, u'Usuário não tem permissão para executar a operação.')

    healthcheck_expect_id = vip_map.get('id_healthcheck_expect')
    if healthcheck_expect_id is not None:
        if not is_valid_int_greater_zero_param(healthcheck_expect_id):
            log.error(
                u'The healthcheck_expect_id parameter is not a valid value: %s.', healthcheck_expect_id)
            raise InvalidValueError(
                None, 'healthcheck_expect_id', healthcheck_expect_id)
        else:
            healthcheck_expect_id = int(healthcheck_expect_id)

    ip_id = vip_map.get('id_ip')
    if not is_valid_int_greater_zero_param(ip_id):
        log.error(u'The ip_id parameter is not a valid value: %s.', ip_id)
        raise InvalidValueError(None, 'ip_id', ip_id)
    else:
        ip_id = int(ip_id)

    validated = vip_map.get('validado')
    if validated is None:
        return 246
    if validated == '0':
        validated = False
    elif validated == '1':
        validated = True
    else:
        return 244

    vip_created = vip_map.get('vip_criado')
    if vip_created is None:
        return 247
    if vip_created == '0':
        vip_created = False
    elif vip_created == '1':
        vip_created = True
    else:
        return 245

    # Valid maxcon
    if not is_valid_int_greater_equal_zero_param(vip_map.get('maxcon')):
        log.error(
            u'The maxcon parameter is not a valid value: %s.', vip_map.get('maxcon'))
        raise InvalidValueError(None, 'maxcon', vip_map.get('maxcon'))

    code = RequisicaoVips.update(user,
                                 vip_id,
                                 vip_map,
                                 healthcheck_expect_id=healthcheck_expect_id,
                                 ip_id=ip_id,
                                 vip_criado=vip_created,
                                 validado=validated)

    if code is not None:
        return code

    return 0
from networkapi.extra_logging import local, NO_REQUEST_ID
from networkapi.ip.models import Ip, IpNotFoundError, IpEquipamento, Ipv6Equipament, Ipv6
from networkapi.equipamento.models import EquipamentoRoteiro
from networkapi.infrastructure import ipaddr
from networkapi.api_network import exceptions
from networkapi.settings import NETWORK_CONFIG_FILES_PATH,\
							 NETWORK_CONFIG_TOAPPLY_REL_PATH, NETWORK_CONFIG_TEMPLATE_PATH
from networkapi.api_deploy.facade import deploy_config_in_equipment_synchronous
from networkapi.distributedlock import distributedlock,LOCK_VLAN, \
								 LOCK_EQUIPMENT_DEPLOY_CONFIG_NETWORK_SCRIPT, LOCK_NETWORK_IPV4, LOCK_NETWORK_IPV6
from networkapi.ip.models import NetworkIPv4, NetworkIPv6
from networkapi.plugins.factory import PluginFactory


log = Log(__name__)

TEMPLATE_NETWORKv4_ACTIVATE = "ipv4_activate_network_configuration"
TEMPLATE_NETWORKv4_DEACTIVATE = "ipv4_deactivate_network_configuration"
TEMPLATE_NETWORKv6_ACTIVATE = "ipv6_activate_network_configuration"
TEMPLATE_NETWORKv6_DEACTIVATE = "ipv6_deactivate_network_configuration"

def deploy_networkIPv4_configuration(user, networkipv4, equipment_list):
	'''Loads template for creating Network IPv4 equipment configuration, creates file and
	apply config.

	Args: equipment_list: NetworkIPv4 object
	equipment_list: Equipamento objects list

	Returns: List with status of equipments output
	'''
def insert_ip(ip_map, user):
    """Insere um IP e o relacionamento entre o IP e o equipamento.

    @param ip_map: Map com as chaves: id_equipamento, id_vlan e descricao
    @param user: Usuário autenticado na API.

    @return Em caso de erro retorna a tupla: (código da mensagem de erro, argumento01, argumento02, ...)
            Em caso de sucesso retorna a tupla: (0, <mapa com os dados do IP>)

    @raise VlanNotFoundError: VLAN não cadastrada.
    @raise VlanError: Falha ao pesquisar a VLAN. 
    @raise EquipamentoNotFoundError: Equipamento não cadastrado.
    @raise EquipamentoError: Falha ao pesquisar o Equipamento. 
    @raise IpNotAvailableError: Não existe um IP disponível para a VLAN.
    @raise IpError: Falha ao inserir no banco de dados.
    @raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.  

    """
    log = Log("insert_ip")

    equip_id = ip_map.get("id_equipamento")
    if not is_valid_int_greater_zero_param(equip_id):
        log.error(u"The equip_id parameter is not a valid value: %s.", equip_id)
        raise InvalidValueError(None, "equip_id", equip_id)
    else:
        equip_id = int(equip_id)

    if not has_perm(
        user,
        AdminPermission.IPS,
        AdminPermission.WRITE_OPERATION,
        None,
        equip_id,
        AdminPermission.EQUIP_WRITE_OPERATION,
    ):
        raise UserNotAuthorizedError(None, u"Usuário não tem permissão para executar a operação.")

    vlan_id = ip_map.get("id_vlan")
    if not is_valid_int_greater_zero_param(vlan_id):
        log.error(u"The vlan_id parameter is not a valid value: %s.", vlan_id)
        raise InvalidValueError(None, "vlan_id", vlan_id)
    else:
        vlan_id = int(vlan_id)

    desc_ip = ip_map.get("descricao")
    if desc_ip is not None:
        if not is_valid_string_maxsize(desc_ip, 100) or not is_valid_string_minsize(desc_ip, 3):
            log.error(u"Parameter desc_ip is invalid. Value: %s.", desc_ip)
            raise InvalidValueError(None, "desc_ip", desc_ip)

    ip = Ip()
    ip.descricao = desc_ip

    ip.create(user, equip_id, vlan_id, False)

    ip_map = dict()
    ip_map["id"] = ip.id
    ip_map["id_redeipv4"] = ip.networkipv4.id
    ip_map["oct4"] = ip.oct4
    ip_map["oct3"] = ip.oct3
    ip_map["oct2"] = ip.oct2
    ip_map["oct1"] = ip.oct1
    ip_map["descricao"] = ip.descricao

    return 0, ip_map