1003 lines
44 KiB
JavaScript
1003 lines
44 KiB
JavaScript
const net = require('net');
|
|
|
|
class FiberhomeManager {
|
|
constructor() {
|
|
this.tl1Connection = null;
|
|
this.commandId = 1;
|
|
|
|
// Configuração apenas para UNM2000 via TL1
|
|
this.config = {
|
|
unm2000: {
|
|
host: '131.0.192.9',
|
|
port: 3337,
|
|
username: '1',
|
|
password: '1',
|
|
timeout: 15000,
|
|
defaultOLT: 'AN5516-06_172.16.10.6' // Nome correto da OLT no sistema
|
|
}
|
|
};
|
|
|
|
this.logger = require('../utils/logger');
|
|
}
|
|
|
|
/**
|
|
* Testar conectividade de rede com um host
|
|
*/
|
|
async testarConectividade(host, port, timeout = 5000) {
|
|
return new Promise((resolve) => {
|
|
const socket = new net.Socket();
|
|
|
|
socket.setTimeout(timeout);
|
|
|
|
socket.connect(port, host, () => {
|
|
this.logger.debug(`Conectividade OK: ${host}:${port}`);
|
|
socket.destroy();
|
|
resolve(true);
|
|
});
|
|
|
|
socket.on('error', (error) => {
|
|
this.logger.debug(`Erro de conectividade ${host}:${port}:`, error.message);
|
|
resolve(false);
|
|
});
|
|
|
|
socket.on('timeout', () => {
|
|
this.logger.debug(`Timeout de conectividade ${host}:${port}`);
|
|
socket.destroy();
|
|
resolve(false);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Conectar ao UNM2000 via TL1
|
|
*/
|
|
async conectarUNM2000() {
|
|
try {
|
|
this.logger.debug('=== INICIO CONEXAO UNM2000 ===');
|
|
this.logger.debug('Configuração:', this.config.unm2000);
|
|
|
|
if (this.tl1Connection && !this.tl1Connection.destroyed) {
|
|
this.logger.debug('Conexão TL1 já existe e está ativa');
|
|
return true;
|
|
}
|
|
|
|
this.logger.debug('Conectando ao UNM2000 via TL1', this.config.unm2000);
|
|
|
|
// Primeiro testar conectividade básica
|
|
this.logger.debug('Testando conectividade básica...');
|
|
const conectividade = await this.testarConectividade(
|
|
this.config.unm2000.host,
|
|
this.config.unm2000.port,
|
|
5000
|
|
);
|
|
|
|
if (!conectividade) {
|
|
this.logger.error(`Host ${this.config.unm2000.host}:${this.config.unm2000.port} não acessível`);
|
|
throw new Error(`Host ${this.config.unm2000.host}:${this.config.unm2000.port} não acessível`);
|
|
}
|
|
|
|
this.logger.debug('Conectividade básica OK, iniciando conexão TL1...');
|
|
|
|
return new Promise((resolve, reject) => {
|
|
this.tl1Connection = new net.Socket();
|
|
let authenticated = false;
|
|
let dataBuffer = '';
|
|
|
|
this.tl1Connection.setTimeout(this.config.unm2000.timeout);
|
|
|
|
// Handler para dados recebidos
|
|
this.tl1Connection.on('data', (data) => {
|
|
const receivedData = data.toString();
|
|
dataBuffer += receivedData;
|
|
this.logger.debug('TL1 dados recebidos:', {
|
|
raw: receivedData,
|
|
buffer: dataBuffer
|
|
});
|
|
|
|
// Verificar padrões de sucesso no login TL1 Fiberhome
|
|
if (!authenticated) {
|
|
if (dataBuffer.includes('COMPLD') ||
|
|
dataBuffer.includes('M COMPLD') ||
|
|
dataBuffer.includes('IP') ||
|
|
dataBuffer.includes('>')) {
|
|
authenticated = true;
|
|
this.logger.info('Login TL1 Fiberhome bem-sucedido');
|
|
resolve(true);
|
|
}
|
|
// Padrões de erro
|
|
else if (dataBuffer.includes('DENY') ||
|
|
dataBuffer.includes('FAIL') ||
|
|
dataBuffer.includes('ERROR')) {
|
|
this.logger.error('Login TL1 negado:', dataBuffer);
|
|
reject(new Error('Login TL1 negado pelo equipamento'));
|
|
}
|
|
}
|
|
});
|
|
|
|
this.tl1Connection.connect(this.config.unm2000.port, this.config.unm2000.host, () => {
|
|
this.logger.debug('Socket TL1 conectado, enviando login Fiberhome');
|
|
|
|
// Aguardar um pouco para receber prompt inicial
|
|
setTimeout(() => {
|
|
// Comando de login TL1 formato Fiberhome
|
|
const loginCommand = `LOGIN:::CTAG::UN=${this.config.unm2000.username},PWD=${this.config.unm2000.password};`;
|
|
this.logger.debug('Enviando comando login TL1 Fiberhome:', loginCommand);
|
|
this.tl1Connection.write(loginCommand + '\r\n');
|
|
}, 1000);
|
|
|
|
// Timeout para autenticação
|
|
setTimeout(() => {
|
|
if (!authenticated) {
|
|
this.logger.error('Timeout na autenticação TL1 - dados recebidos:', dataBuffer);
|
|
reject(new Error(`Timeout na autenticação TL1. Dados: ${dataBuffer.substring(0, 200)}`));
|
|
}
|
|
}, 12000);
|
|
});
|
|
|
|
this.tl1Connection.on('error', (error) => {
|
|
this.logger.error('Erro na conexão TL1', error);
|
|
reject(error);
|
|
});
|
|
|
|
this.tl1Connection.on('timeout', () => {
|
|
this.logger.error('Timeout na conexão TL1');
|
|
reject(new Error('Timeout na conexão TL1'));
|
|
});
|
|
|
|
this.tl1Connection.on('close', () => {
|
|
this.logger.debug('Conexão TL1 fechada');
|
|
this.tl1Connection = null;
|
|
});
|
|
});
|
|
|
|
} catch (error) {
|
|
this.logger.error('=== ERRO NA CONEXAO UNM2000 ===');
|
|
this.logger.error('Erro detalhado:', {
|
|
message: error.message,
|
|
code: error.code,
|
|
errno: error.errno,
|
|
syscall: error.syscall,
|
|
address: error.address,
|
|
port: error.port
|
|
});
|
|
this.logger.error('Erro ao conectar UNM2000', error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Método de teste para verificar comandos TL1 básicos
|
|
*/
|
|
async testarComandoTL1(comando) {
|
|
try {
|
|
this.logger.debug('=== TESTE TL1 ===');
|
|
this.logger.debug('Comando:', comando);
|
|
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
|
|
const resultado = await this.executarComandoTL1(comando);
|
|
|
|
this.logger.debug('=== RESULTADO TESTE TL1 ===');
|
|
this.logger.debug('Success:', resultado.success);
|
|
this.logger.debug('Error:', resultado.error);
|
|
this.logger.debug('Data length:', resultado.data ? resultado.data.length : 0);
|
|
this.logger.debug('Data:', resultado.data);
|
|
this.logger.debug('=== FIM TESTE TL1 ===');
|
|
|
|
return resultado;
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro no teste TL1:', error.message);
|
|
return { success: false, error: error.message };
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Executar comando TL1
|
|
*/
|
|
async executarComandoTL1(comando) {
|
|
try {
|
|
this.logger.debug('Executando comando TL1', { comando });
|
|
|
|
if (!this.tl1Connection || this.tl1Connection.destroyed) {
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
let dataBuffer = '';
|
|
let responseReceived = false;
|
|
|
|
// Handler temporário para esta consulta
|
|
const dataHandler = (data) => {
|
|
dataBuffer += data.toString();
|
|
this.logger.debug('Resposta TL1 acumulada:', {
|
|
comando,
|
|
responseLength: dataBuffer.length,
|
|
response: dataBuffer
|
|
});
|
|
|
|
// Verificar se a resposta está completa (formato Fiberhome)
|
|
if ((dataBuffer.includes('COMPLD') ||
|
|
dataBuffer.includes('M COMPLD') ||
|
|
dataBuffer.includes('DENY') ||
|
|
dataBuffer.includes(';')) && !responseReceived) {
|
|
responseReceived = true;
|
|
this.tl1Connection.removeListener('data', dataHandler);
|
|
|
|
if (dataBuffer.includes('COMPLD') || dataBuffer.includes('M COMPLD')) {
|
|
this.logger.debug('Comando TL1 executado com sucesso');
|
|
resolve({
|
|
success: true,
|
|
data: dataBuffer
|
|
});
|
|
} else if (dataBuffer.includes('DENY')) {
|
|
this.logger.warn('Comando TL1 negado pelo equipamento');
|
|
resolve({
|
|
success: false,
|
|
error: 'Comando negado pelo equipamento',
|
|
data: dataBuffer
|
|
});
|
|
} else {
|
|
this.logger.debug('Resposta TL1 válida recebida');
|
|
resolve({
|
|
success: true,
|
|
data: dataBuffer // Aceitar resposta válida
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
this.tl1Connection.on('data', dataHandler);
|
|
|
|
// Enviar comando TL1 formato Fiberhome
|
|
this.tl1Connection.write(comando + '\r\n');
|
|
|
|
// Timeout para resposta
|
|
setTimeout(() => {
|
|
if (!responseReceived) {
|
|
this.tl1Connection.removeListener('data', dataHandler);
|
|
reject(new Error('Timeout aguardando resposta TL1'));
|
|
}
|
|
}, 15000);
|
|
});
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao executar comando TL1', { comando, error: error.message });
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obter status de ONU via TL1
|
|
*/
|
|
async obterStatusONU(serial) {
|
|
try {
|
|
this.logger.debug('Obtendo status da ONU via TL1', { serial });
|
|
|
|
// Conectar ao UNM2000
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
|
|
const oltId = this.config.unm2000.defaultOLT; // Nome correto da OLT
|
|
|
|
// BUSCA AUTOMATIZADA: Estrutura correta da OLT
|
|
this.logger.debug('=== INICIANDO BUSCA AUTOMATIZADA POR SLOT/PON ===');
|
|
this.logger.debug(`OLTID: ${oltId}, Serial: ${serial}`);
|
|
|
|
// Definir estrutura correta da OLT
|
|
const estruturaOLT = [
|
|
// Slots 12, 13, 14 com 16 PONs cada
|
|
{ slot: 12, maxPons: 16 },
|
|
{ slot: 13, maxPons: 16 },
|
|
{ slot: 14, maxPons: 16 },
|
|
// Slots 15, 16 com 8 PONs cada
|
|
{ slot: 15, maxPons: 8 },
|
|
{ slot: 16, maxPons: 8 }
|
|
];
|
|
|
|
// Gerar lista de PONs para busca
|
|
const listaPons = [];
|
|
estruturaOLT.forEach(estrutura => {
|
|
for (let pon = 1; pon <= estrutura.maxPons; pon++) {
|
|
listaPons.push(`1-1-${estrutura.slot}-${pon}`);
|
|
}
|
|
});
|
|
|
|
this.logger.info(`📡 Iniciando busca em ${listaPons.length} PONs: slots 12-16`);
|
|
|
|
let onuEncontrada = null;
|
|
let ponEncontrada = null;
|
|
|
|
// Buscar em cada PON até encontrar a ONU
|
|
for (const ponid of listaPons) {
|
|
try {
|
|
this.logger.debug(`🔍 Verificando PON ${ponid}...`);
|
|
|
|
// Listar ONUs desta PON específica
|
|
const comandoListarPon = `LST-ONU::OLTID=${oltId},PONID=${ponid}:CTAG::;`;
|
|
const resultadoPon = await this.executarComandoTL1(comandoListarPon);
|
|
|
|
if (resultadoPon.success) {
|
|
// Verificar se a ONU está nesta PON (busca case-insensitive)
|
|
const serialUpperCase = serial.toUpperCase();
|
|
const dataUpperCase = resultadoPon.data ? resultadoPon.data.toUpperCase() : '';
|
|
|
|
if (resultadoPon.data && dataUpperCase.includes(serialUpperCase)) {
|
|
// Extrair informações da ONU na listagem primeiro
|
|
const posicaoONU = this.extrairPosicaoONU(resultadoPon.data, serial);
|
|
|
|
if (posicaoONU) {
|
|
// Usar o PONID correto extraído dos dados reais
|
|
this.logger.info(`🎯 ONU ${serial} ENCONTRADA NA PON ${posicaoONU.ponid}!`);
|
|
|
|
// Log dos dados da PON para debug
|
|
this.logger.debug('Dados da PON onde ONU foi encontrada:', {
|
|
ponidBuscada: ponid,
|
|
ponidReal: posicaoONU.ponid,
|
|
dataLength: resultadoPon.data.length,
|
|
preview: resultadoPon.data.substring(0, 1000)
|
|
});
|
|
|
|
onuEncontrada = {
|
|
posicao: posicaoONU,
|
|
listagem: resultadoPon.data,
|
|
ponid: posicaoONU.ponid // Usar o PONID correto extraído dos dados
|
|
};
|
|
ponEncontrada = posicaoONU.ponid; // Usar o PONID correto extraído dos dados
|
|
|
|
// Extrair slot e PON do ponid encontrado
|
|
const [, , slot, pon] = posicaoONU.ponid.split('-');
|
|
this.logger.info(`📍 Localização: Slot ${slot}, PON ${pon}`);
|
|
|
|
break; // Encontrou, pode parar a busca
|
|
}
|
|
}
|
|
} else {
|
|
this.logger.debug(`❌ Erro na PON ${ponid}: ${resultadoPon.error}`);
|
|
}
|
|
|
|
} catch (error) {
|
|
this.logger.debug(`⚠️ Erro ao verificar PON ${ponid}: ${error.message}`);
|
|
// Continuar tentando outras PONs
|
|
}
|
|
}
|
|
|
|
if (!onuEncontrada) {
|
|
throw new Error(`ONU ${serial} não encontrada em nenhuma PON da OLT ${oltId}. Verifique se o serial está correto e se a ONU está cadastrada.`);
|
|
}
|
|
|
|
// Agora buscar informações detalhadas da ONU
|
|
this.logger.info(`📊 Coletando informações detalhadas da ONU na PON ${ponEncontrada}...`);
|
|
|
|
// Extrair número da ONU da posição encontrada
|
|
const numeroONU = onuEncontrada.posicao.onuno;
|
|
|
|
// Usar comandos TL1 que sabemos que funcionam baseados no manual
|
|
const comandosDetalhados = [
|
|
// Para informações de distância e estado (comando válido do manual)
|
|
`LST-ONUSTATE::OLTID=${oltId},PONID=${ponEncontrada},ONUNO=${numeroONU}:CTAG::;`,
|
|
// Para informações DDM/potência ótica (comando válido do manual)
|
|
`LST-OMDDM::OLTID=${oltId},PONID=${ponEncontrada},ONUNO=${numeroONU}:CTAG::;`,
|
|
// Para informações das portas LAN (comando válido do manual)
|
|
`LST-ONULANINFO::OLTID=${oltId},PONID=${ponEncontrada},ONUNO=${numeroONU}:CTAG::;`
|
|
];
|
|
|
|
this.logger.debug('Executando comandos TL1 detalhados:', comandosDetalhados);
|
|
|
|
const [resultadoEstado, resultadoDDM, resultadoLAN] = await Promise.all([
|
|
this.executarComandoTL1(comandosDetalhados[0]),
|
|
this.executarComandoTL1(comandosDetalhados[1]),
|
|
this.executarComandoTL1(comandosDetalhados[2])
|
|
]);
|
|
|
|
// LOG COMPLETO DO LST-OMDDM PARA DEBUG - FORÇAR CONSOLE OUTPUT
|
|
if (resultadoDDM.success && resultadoDDM.data) {
|
|
const separador = '='.repeat(80);
|
|
console.log('\n' + separador);
|
|
console.log('LST-OMDDM RESPOSTA COMPLETA');
|
|
console.log(separador);
|
|
console.log('Comando: ' + comandosDetalhados[1]);
|
|
console.log('Resposta RAW:');
|
|
console.log(resultadoDDM.data);
|
|
console.log(separador + '\n');
|
|
|
|
// Verificar se é resposta válida de DDM
|
|
if (!resultadoDDM.data.includes('RxPower') && !resultadoDDM.data.includes('Optical Power')) {
|
|
console.log('⚠️ ATENÇÃO: LST-OMDDM retornou formato inesperado!');
|
|
console.log('⚠️ Resposta parece ser lista de ONUs ao invés de dados DDM');
|
|
console.log('⚠️ Verifique se o comando está correto para esta versão do equipamento');
|
|
}
|
|
}
|
|
|
|
// Adicionar dados coletados
|
|
onuEncontrada.estadoGeral = resultadoEstado.success ? resultadoEstado.data : null;
|
|
onuEncontrada.detalhes = resultadoDDM.success ? resultadoDDM.data : null;
|
|
onuEncontrada.lan = resultadoLAN.success ? resultadoLAN.data : null;
|
|
|
|
// Adicionar respostas detalhadas para processamento
|
|
onuEncontrada.detalhados = [
|
|
{ comando: comandosDetalhados[0], response: resultadoEstado.data, success: resultadoEstado.success },
|
|
{ comando: comandosDetalhados[1], response: resultadoDDM.data, success: resultadoDDM.success },
|
|
{ comando: comandosDetalhados[2], response: resultadoLAN.data, success: resultadoLAN.success }
|
|
];
|
|
|
|
// Log dos resultados dos comandos detalhados
|
|
this.logger.debug('📊 Resultados dos comandos detalhados:', {
|
|
estado: { success: resultadoEstado.success, length: resultadoEstado.data?.length || 0 },
|
|
ddm: { success: resultadoDDM.success, length: resultadoDDM.data?.length || 0 },
|
|
lan: { success: resultadoLAN.success, length: resultadoLAN.data?.length || 0 }
|
|
});
|
|
|
|
// Tentar extrair mais informações dos dados da listagem original
|
|
this.logger.debug('📋 Processando dados da listagem original para extrair informações...');
|
|
onuEncontrada.dadosOriginais = onuEncontrada.listagem;
|
|
|
|
// Processar todos os dados coletados
|
|
const statusONU = this.processarStatusONUTL1(onuEncontrada, serial);
|
|
|
|
this.logger.info('🎉 Status final da ONU processado:', {
|
|
serial: statusONU.serial,
|
|
slot: statusONU.slot,
|
|
pon: statusONU.pon,
|
|
online: statusONU.online,
|
|
rxPower: statusONU.rxPower,
|
|
txPower: statusONU.txPower
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
...statusONU
|
|
};
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao obter status da ONU via TL1', { serial, error: error.message });
|
|
return {
|
|
success: false,
|
|
error: error.message,
|
|
serial
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obter status da ONU por device name via TL1
|
|
*/
|
|
async obterStatusONUPorNome(deviceName) {
|
|
try {
|
|
this.logger.debug('Obtendo status da ONU por nome via TL1', { deviceName });
|
|
|
|
// Conectar ao UNM2000
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
|
|
// Comando TL1 para buscar ONU por nome
|
|
const comando = `RTRV-ONU::${deviceName}:1;`;
|
|
this.logger.debug('Executando comando TL1', { comando });
|
|
|
|
const resultado = await this.executarComandoTL1(comando);
|
|
|
|
if (!resultado.success) {
|
|
throw new Error(resultado.error || 'Falha na consulta TL1');
|
|
}
|
|
|
|
// Processar resposta TL1 da ONU
|
|
const statusONU = this.processarStatusONUTL1(resultado.data, deviceName);
|
|
|
|
this.logger.debug('Status ONU processado via TL1', statusONU);
|
|
|
|
return {
|
|
success: true,
|
|
...statusONU
|
|
};
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao obter status da ONU por nome via TL1', { deviceName, error: error.message });
|
|
return {
|
|
success: false,
|
|
error: error.message,
|
|
deviceName
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Extrair posição da ONU da lista de ONUs
|
|
*/
|
|
extrairPosicaoONU(dadosLista, serial) {
|
|
try {
|
|
if (!dadosLista || typeof dadosLista !== 'string') {
|
|
return null;
|
|
}
|
|
|
|
this.logger.debug('Extraindo posição da ONU da resposta TL1:', {
|
|
serial,
|
|
serialUpperCase: serial.toUpperCase(),
|
|
responseLength: dadosLista.length,
|
|
preview: dadosLista.substring(0, 500)
|
|
});
|
|
|
|
// Dividir resposta em linhas para processamento
|
|
const linhas = dadosLista.split('\n');
|
|
|
|
this.logger.debug('Total de linhas para processar:', linhas.length);
|
|
|
|
for (const linha of linhas) {
|
|
// Pular linhas de cabeçalho e vazias
|
|
if (linha.includes('OLTID') || linha.includes('----') || linha.trim() === '') {
|
|
continue;
|
|
}
|
|
|
|
// Log de cada linha processada (apenas as primeiras 3 para não poluir)
|
|
if (linhas.indexOf(linha) < 3) {
|
|
this.logger.debug('Processando linha:', linha.substring(0, 200));
|
|
}
|
|
|
|
// Procurar linha que contém o serial na coluna MAC (busca case-insensitive)
|
|
const serialUpperCase = serial.toUpperCase();
|
|
const linhaUpperCase = linha.toUpperCase();
|
|
|
|
if (linhaUpperCase.includes(serialUpperCase)) {
|
|
this.logger.debug('Serial encontrado na linha:', linha);
|
|
|
|
// Formato esperado baseado nos logs:
|
|
// OLTID PONID ONUNO NAME DESC ONUTYPE IP AUTHTYPE MAC LOID PWD SWVER
|
|
// 172.16.10.6 1-1-14-2 68 artenizamendes@clicknetguarai.com.br -- AN5506-02-B -- MAC FHTT92704618 -- -- RP2604
|
|
|
|
// Dividir por tabs
|
|
const campos = linha.split('\t');
|
|
this.logger.debug('Campos extraídos por TAB:', campos);
|
|
|
|
if (campos.length >= 9) {
|
|
const oltid = campos[0];
|
|
const ponid = campos[1];
|
|
const onuno = campos[2];
|
|
const name = campos[3];
|
|
const mac = campos[8]; // Posição da coluna MAC
|
|
|
|
// Verificar se o MAC corresponde ao serial procurado (case-insensitive)
|
|
if (mac && mac.toUpperCase().includes(serialUpperCase)) {
|
|
this.logger.debug('PONID encontrado:', ponid);
|
|
return {
|
|
ponid: ponid,
|
|
encontrado: true,
|
|
oltid: oltid,
|
|
onuno: onuno,
|
|
name: name,
|
|
mac: mac,
|
|
linhaOriginal: linha
|
|
};
|
|
}
|
|
}
|
|
|
|
// Fallback: se não conseguiu dividir por TAB, tentar por espaços
|
|
const camposEspaco = linha.trim().split(/\s+/);
|
|
this.logger.debug('Campos extraídos por espaço:', camposEspaco);
|
|
|
|
// Procurar o campo PONID (formato x-x-x-x) e verificar se serial está na linha
|
|
for (let i = 0; i < camposEspaco.length; i++) {
|
|
const campo = camposEspaco[i];
|
|
if (campo.match(/^\d+-\d+-\d+-\d+$/) && linhaUpperCase.includes(serialUpperCase)) {
|
|
this.logger.debug('PONID encontrado por regex:', campo);
|
|
return {
|
|
ponid: campo,
|
|
encontrado: true,
|
|
linhaOriginal: linha
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.logger.warn('ONU não encontrada na listagem TL1', { serial });
|
|
return null;
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao extrair posição da ONU', { error: error.message, serial });
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Processar resposta TL1 para status de ONU
|
|
*/
|
|
processarStatusONUTL1(dadosONU, identificador) {
|
|
try {
|
|
const resultado = {
|
|
serial: identificador,
|
|
deviceName: identificador,
|
|
slot: 'N/A',
|
|
pon: 'N/A',
|
|
onuId: 'N/A',
|
|
online: false,
|
|
rxPower: 'N/A',
|
|
txPower: 'N/A',
|
|
distance: 'N/A',
|
|
portasEthernet: [],
|
|
servicosWAN: []
|
|
};
|
|
|
|
if (!dadosONU || typeof dadosONU !== 'object') {
|
|
return resultado;
|
|
}
|
|
|
|
this.logger.debug('Processando dados ONU TL1:', dadosONU);
|
|
|
|
// Se encontramos a posição, a ONU existe
|
|
if (dadosONU.posicao && dadosONU.posicao.encontrado) {
|
|
resultado.online = true;
|
|
|
|
// Extrair informações da posição (formato NA-NA-slot-pon ou NA-shelf-slot-pon)
|
|
const ponid = dadosONU.posicao.ponid;
|
|
const partesPonid = ponid.split('-');
|
|
|
|
this.logger.debug('Analisando PONID:', { ponid, partes: partesPonid });
|
|
|
|
if (partesPonid.length >= 4) {
|
|
// Formato NA-NA-slot-pon ou NA-shelf-slot-pon
|
|
resultado.slot = partesPonid[2];
|
|
resultado.pon = partesPonid[3];
|
|
// Incluir o número da ONU no ID (slot-pon-numeroONU)
|
|
const numeroONU = dadosONU.posicao.onuno || '?';
|
|
resultado.onuId = `${partesPonid[2]}-${partesPonid[3]}-${numeroONU}`;
|
|
}
|
|
|
|
// Processar dados específicos dos comandos TL1 detalhados
|
|
if (dadosONU.detalhados) {
|
|
this.logger.debug('Processando respostas dos comandos TL1 detalhados');
|
|
|
|
for (const resposta of dadosONU.detalhados) {
|
|
if (!resposta || !resposta.response) continue;
|
|
|
|
const dados = resposta.response;
|
|
|
|
// Processar LST-ONUSTATE (distância e estado)
|
|
if (resposta.comando && resposta.comando.includes('LST-ONUSTATE')) {
|
|
// Extrair distância
|
|
const distMatch = dados.match(/DISTANCE\s*=\s*(\d+)/i) ||
|
|
dados.match(/RANGING\s*=\s*(\d+)/i);
|
|
if (distMatch) {
|
|
resultado.distance = `${distMatch[1]} m`;
|
|
}
|
|
|
|
// Verificar estado online/offline
|
|
if (dados.includes('ONLINE') || dados.includes('ACTIVE')) {
|
|
resultado.online = true;
|
|
} else if (dados.includes('OFFLINE') || dados.includes('INACTIVE')) {
|
|
resultado.online = false;
|
|
}
|
|
}
|
|
|
|
// Processar LST-OMDDM (potência ótica)
|
|
if (resposta.comando && resposta.comando.includes('LST-OMDDM')) {
|
|
// Verificar se a resposta é válida (deve conter "Optical Power" ou campos de potência)
|
|
if (!dados.includes('RxPower') && !dados.includes('Optical Power')) {
|
|
this.logger.warn('⚠️ LST-OMDDM retornou formato inesperado, pulando...');
|
|
continue;
|
|
}
|
|
|
|
// Buscar pela tabela de potência ótica
|
|
const linhasTabela = dados.split('\n').filter(linha =>
|
|
linha.includes('\t') &&
|
|
!linha.includes('ONUID') &&
|
|
!linha.includes('OLTID') && // Não é lista de ONUs
|
|
!linha.includes('---') &&
|
|
linha.match(/[+-]?\d+[,.]?\d*/)
|
|
);
|
|
|
|
this.logger.debug(`📋 LST-OMDDM: ${linhasTabela.length} linhas encontradas`);
|
|
|
|
if (linhasTabela.length > 0) {
|
|
const campos = linhasTabela[0].split('\t');
|
|
this.logger.debug(`📊 LST-OMDDM campos: [${campos.join('] [')}]`);
|
|
|
|
// Formato: ONUID RxPower RxPowerR TxPower TxPowerR CurrTxBias CurrTxBiasR
|
|
// Temperature TemperatureR Voltage VoltageR PTxPower PRxPower
|
|
// Índices: 0 1 2 3 4 5 6
|
|
// 7 8 9 10 11 12
|
|
|
|
// RxPower = sinal que a OLT recebe da ONU (uplink) - campo 1
|
|
const rxPower = campos[1]?.replace(',', '.').trim();
|
|
// PTxPower = potência transmitida pela ONU - campo 11
|
|
const ptxPower = campos[11]?.replace(',', '.').trim();
|
|
|
|
if (rxPower && rxPower !== '--' && !isNaN(parseFloat(rxPower))) {
|
|
resultado.rxPower = `${rxPower} dBm`;
|
|
this.logger.info(`✅ RX Power extraído: ${rxPower} dBm`);
|
|
} else {
|
|
this.logger.warn(`⚠️ RxPower inválido: "${rxPower}"`);
|
|
}
|
|
|
|
if (ptxPower && ptxPower !== '--' && !isNaN(parseFloat(ptxPower))) {
|
|
resultado.txPower = `${ptxPower} dBm`;
|
|
this.logger.info(`✅ TX Power extraído (PTxPower): ${ptxPower} dBm`);
|
|
} else {
|
|
this.logger.warn(`⚠️ PTxPower inválido: "${ptxPower}"`);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Processar LST-ONULANINFO (portas ethernet)
|
|
if (resposta.comando && resposta.comando.includes('LST-ONULANINFO')) {
|
|
// Extrair informações das portas
|
|
const portMatches = dados.matchAll(/PORT\s*=\s*(\d+).*?STATUS\s*=\s*(\w+)/gi);
|
|
for (const match of portMatches) {
|
|
const portNum = parseInt(match[1]);
|
|
const status = match[2].toLowerCase();
|
|
|
|
if (portNum >= 1 && portNum <= 4) {
|
|
if (!resultado.portasEthernet[portNum-1]) {
|
|
resultado.portasEthernet[portNum-1] = { porta: portNum, status: 'unknown' };
|
|
}
|
|
resultado.portasEthernet[portNum-1].status = status === 'up' ? 'active' :
|
|
status === 'down' ? 'inactive' : 'unknown';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Tentar extrair distância dos dados da listagem (onde já funcionou)
|
|
if (dadosONU.listagem || dadosONU.dadosOriginais) {
|
|
const dadosCompletos = dadosONU.listagem || dadosONU.dadosOriginais;
|
|
|
|
// Análise específica do formato TL1 tabular
|
|
const linhasTabela = dadosCompletos.split('\r\n').filter(linha =>
|
|
linha.includes('\t') &&
|
|
linha.includes(dadosONU.posicao.mac.toLowerCase()) &&
|
|
!linha.includes('OLTID\tPONID')
|
|
);
|
|
|
|
if (linhasTabela.length > 0) {
|
|
const campos = linhasTabela[0].split('\t');
|
|
// Último campo geralmente contém código de ranging (ex: RP2610)
|
|
const ultimoCampo = campos[campos.length - 1];
|
|
|
|
// Extrair número do código RP (Ranging Profile)
|
|
const rpMatch = ultimoCampo.match(/RP(\d{2})(\d{2})/);
|
|
if (rpMatch) {
|
|
// RP2610 = distância baseada no perfil
|
|
// Converter baseado em padrões típicos dos equipamentos Fiberhome
|
|
const codigoDistancia = parseInt(rpMatch[2]);
|
|
if (codigoDistancia > 0) {
|
|
// Estimativa baseada no código (cada unidade pode representar ~100m)
|
|
const distanciaEstimada = codigoDistancia * 10;
|
|
resultado.distance = `${distanciaEstimada} m`;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Procurar por dados de distância explícitos na listagem
|
|
const distanciaMatches = [
|
|
dadosCompletos.match(/DISTANCE[=\s:]+(\d+)/gi),
|
|
dadosCompletos.match(/RANGING[=\s:]+(\d+)/gi),
|
|
dadosCompletos.match(/RANGE[=\s:]+(\d+)/gi),
|
|
// Buscar por padrões mais específicos de distância com metros (mínimo 3 dígitos)
|
|
dadosCompletos.match(/\b(\d{3,4})\s*m(?:etros?)?\b/gi)
|
|
];
|
|
|
|
for (const matches of distanciaMatches) {
|
|
if (matches && matches.length > 0) {
|
|
// Pegar o primeiro match válido
|
|
const match = matches[0].match(/(\d+)/);
|
|
if (match) {
|
|
resultado.distance = `${match[1]} m`;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extrair informações de potência se disponível na listagem
|
|
const rxMatches = [
|
|
dadosCompletos.match(/RX[=\s:]+([+-]?\d+\.?\d*)/gi),
|
|
dadosCompletos.match(/RXPOWER[=\s:]+([+-]?\d+\.?\d*)/gi)
|
|
];
|
|
|
|
for (const matches of rxMatches) {
|
|
if (matches && matches.length > 0) {
|
|
const match = matches[0].match(/([+-]?\d+\.?\d*)/);
|
|
if (match) {
|
|
resultado.rxPower = `${match[1]} dBm`;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const txMatches = [
|
|
dadosCompletos.match(/TX[=\s:]+([+-]?\d+\.?\d*)/gi),
|
|
dadosCompletos.match(/TXPOWER[=\s:]+([+-]?\d+\.?\d*)/gi)
|
|
];
|
|
|
|
for (const matches of txMatches) {
|
|
if (matches && matches.length > 0) {
|
|
const match = matches[0].match(/([+-]?\d+\.?\d*)/);
|
|
if (match) {
|
|
resultado.txPower = `${match[1]} dBm`;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Processar dados detalhados se disponível
|
|
if (dadosONU.detalhes) {
|
|
this.logger.debug('Processando dados detalhados da ONU:', dadosONU.detalhes);
|
|
|
|
// Extrair RX Power
|
|
const rxMatches = [
|
|
dadosONU.detalhes.match(/RXPOWER[=\s:]+([+-]?\d+\.?\d*)/i),
|
|
dadosONU.detalhes.match(/RX[=\s:]+([+-]?\d+\.?\d*)/i)
|
|
];
|
|
|
|
for (const match of rxMatches) {
|
|
if (match) {
|
|
resultado.rxPower = `${match[1]} dBm`;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Extrair TX Power
|
|
const txMatches = [
|
|
dadosONU.detalhes.match(/TXPOWER[=\s:]+([+-]?\d+\.?\d*)/i),
|
|
dadosONU.detalhes.match(/TX[=\s:]+([+-]?\d+\.?\d*)/i)
|
|
];
|
|
|
|
for (const match of txMatches) {
|
|
if (match) {
|
|
resultado.txPower = `${match[1]} dBm`;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Extrair distância
|
|
const distMatches = [
|
|
dadosONU.detalhes.match(/DISTANCE[=\s:]+(\d+)/i),
|
|
dadosONU.detalhes.match(/RANGINGTIME[=\s:]+(\d+)/i)
|
|
];
|
|
|
|
for (const match of distMatches) {
|
|
if (match) {
|
|
resultado.distance = `${match[1]} m`;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Processar dados de estado geral se disponível
|
|
if (dadosONU.estadoGeral) {
|
|
this.logger.debug('Processando dados de estado geral:', dadosONU.estadoGeral);
|
|
|
|
// Verificar se está online/offline
|
|
if (dadosONU.estadoGeral.includes('ONLINE') ||
|
|
dadosONU.estadoGeral.includes('ACTIVE') ||
|
|
dadosONU.estadoGeral.includes('UP')) {
|
|
resultado.online = true;
|
|
} else if (dadosONU.estadoGeral.includes('OFFLINE') ||
|
|
dadosONU.estadoGeral.includes('INACTIVE') ||
|
|
dadosONU.estadoGeral.includes('DOWN')) {
|
|
resultado.online = false;
|
|
}
|
|
}
|
|
|
|
// Se não temos dados específicos das portas, usar padrão
|
|
if (resultado.portasEthernet.length === 0) {
|
|
resultado.portasEthernet = [
|
|
{ porta: 1, status: 'unknown' },
|
|
{ porta: 2, status: 'unknown' },
|
|
{ porta: 3, status: 'unknown' },
|
|
{ porta: 4, status: 'unknown' }
|
|
];
|
|
}
|
|
|
|
// Se não temos dados WAN específicos, mas a ONU está online
|
|
if (resultado.servicosWAN.length === 0 && resultado.online) {
|
|
resultado.servicosWAN.push({
|
|
id: 1,
|
|
status: 'active',
|
|
ip: 'Configurado'
|
|
});
|
|
}
|
|
}
|
|
|
|
this.logger.debug('Dados TL1 processados:', resultado);
|
|
return resultado;
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao processar dados TL1', { error: error.message });
|
|
return {
|
|
serial: identificador,
|
|
deviceName: identificador,
|
|
slot: 'N/A',
|
|
pon: 'N/A',
|
|
onuId: 'N/A',
|
|
online: false,
|
|
rxPower: 'N/A',
|
|
txPower: 'N/A',
|
|
distance: 'N/A',
|
|
portasEthernet: [],
|
|
servicosWAN: []
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Desconectar TL1
|
|
*/
|
|
async desconectar() {
|
|
try {
|
|
if (this.tl1Connection && !this.tl1Connection.destroyed) {
|
|
this.logger.debug('Desconectando TL1');
|
|
this.tl1Connection.end();
|
|
this.tl1Connection = null;
|
|
}
|
|
} catch (error) {
|
|
this.logger.error('Erro ao desconectar TL1', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verificar se as conexões estão ativas
|
|
*/
|
|
verificarConexoes() {
|
|
return {
|
|
olt: false, // Não usamos mais OLT diretamente
|
|
unm2000: this.tl1Connection && !this.tl1Connection.destroyed
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Diagnóstico completo de conectividade
|
|
*/
|
|
async diagnosticarConectividade() {
|
|
const diagnostico = {
|
|
olt: {
|
|
host: 'N/A',
|
|
port: 'N/A',
|
|
conectividade: false,
|
|
telnet: false,
|
|
erro: 'Não utilizado - consultas via TL1'
|
|
},
|
|
unm2000: {
|
|
host: this.config.unm2000.host,
|
|
port: this.config.unm2000.port,
|
|
conectividade: false,
|
|
tl1: false,
|
|
erro: null
|
|
}
|
|
};
|
|
|
|
// Testar UNM2000
|
|
try {
|
|
this.logger.debug('Testando conectividade UNM2000...');
|
|
diagnostico.unm2000.conectividade = await this.testarConectividade(
|
|
this.config.unm2000.host,
|
|
this.config.unm2000.port
|
|
);
|
|
|
|
if (diagnostico.unm2000.conectividade) {
|
|
this.logger.debug('Testando login TL1 UNM2000...');
|
|
diagnostico.unm2000.tl1 = await this.conectarUNM2000();
|
|
}
|
|
} catch (error) {
|
|
diagnostico.unm2000.erro = error.message;
|
|
this.logger.error('Erro no diagnóstico UNM2000:', error);
|
|
}
|
|
|
|
return diagnostico;
|
|
}
|
|
}
|
|
|
|
module.exports = FiberhomeManager;
|