676 lines
26 KiB
JavaScript
676 lines
26 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
|
|
},
|
|
olt: {
|
|
name: '131.0.192.9' // OLT configurada no TL1
|
|
}
|
|
};
|
|
|
|
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 {
|
|
if (this.tl1Connection && !this.tl1Connection.destroyed) {
|
|
console.log('✅ Conexão TL1 já existe e está ativa');
|
|
this.logger.debug('Conexão TL1 já existe e está ativa');
|
|
return true;
|
|
}
|
|
|
|
console.log('🔌 Conectando ao UNM2000 via TL1:', this.config.unm2000);
|
|
this.logger.debug('Conectando ao UNM2000 via TL1', this.config.unm2000);
|
|
|
|
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) => {
|
|
dataBuffer += data.toString();
|
|
console.log('📥 TL1 dados recebidos:', dataBuffer);
|
|
this.logger.debug('TL1 dados recebidos:', dataBuffer);
|
|
|
|
// Verificar se login foi bem-sucedido
|
|
if (!authenticated && dataBuffer.includes('COMPLD')) {
|
|
authenticated = true;
|
|
console.log('✅ Login TL1 bem-sucedido!');
|
|
this.logger.info('Login TL1 bem-sucedido');
|
|
resolve(true);
|
|
} else if (!authenticated && dataBuffer.includes('DENY')) {
|
|
console.log('❌ Login TL1 negado!');
|
|
this.logger.error('Login TL1 negado');
|
|
reject(new Error('Login TL1 negado'));
|
|
}
|
|
});
|
|
|
|
this.tl1Connection.connect(this.config.unm2000.port, this.config.unm2000.host, () => {
|
|
console.log('🔗 Socket TL1 conectado, enviando comando de login');
|
|
this.logger.debug('Socket TL1 conectado, enviando comando de login');
|
|
|
|
// Comando de login TL1 - formato correto: LOGIN:::CTAG::UN=username,PWD=password;
|
|
const loginCommand = `LOGIN:::${this.commandId++}::UN=${this.config.unm2000.username},PWD=${this.config.unm2000.password};`;
|
|
console.log('📤 Enviando login:', loginCommand);
|
|
this.tl1Connection.write(loginCommand + '\r\n');
|
|
|
|
// Timeout para autenticação
|
|
setTimeout(() => {
|
|
if (!authenticated) {
|
|
console.log('⏱️ Timeout na autenticação TL1 (10s). DataBuffer:', dataBuffer);
|
|
this.logger.error('Timeout na autenticação TL1', { dataBuffer });
|
|
reject(new Error('Timeout na autenticação TL1'));
|
|
}
|
|
}, 10000);
|
|
});
|
|
|
|
this.tl1Connection.on('error', (error) => {
|
|
console.log('❌ Erro na conexão TL1:', error.message);
|
|
this.logger.error('Erro na conexão TL1', error);
|
|
reject(error);
|
|
});
|
|
|
|
this.tl1Connection.on('timeout', () => {
|
|
console.log('⏱️ Timeout do socket TL1');
|
|
this.logger.error('Timeout na conexão TL1');
|
|
reject(new Error('Timeout na conexão TL1'));
|
|
});
|
|
|
|
this.tl1Connection.on('close', () => {
|
|
console.log('🔌 Conexão TL1 fechada');
|
|
this.logger.debug('Conexão TL1 fechada');
|
|
this.tl1Connection = null;
|
|
});
|
|
});
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao conectar UNM2000', error);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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 recebida:', dataBuffer);
|
|
|
|
// Verificar se a resposta está completa (termina com ;)
|
|
if (dataBuffer.includes(';') && !responseReceived) {
|
|
responseReceived = true;
|
|
this.tl1Connection.removeListener('data', dataHandler);
|
|
|
|
if (dataBuffer.includes('COMPLD')) {
|
|
resolve({
|
|
success: true,
|
|
data: dataBuffer
|
|
});
|
|
} else if (dataBuffer.includes('DENY')) {
|
|
resolve({
|
|
success: false,
|
|
error: 'Comando negado pelo equipamento'
|
|
});
|
|
} else {
|
|
resolve({
|
|
success: false,
|
|
error: 'Resposta inválida do equipamento'
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
this.tl1Connection.on('data', dataHandler);
|
|
|
|
// Enviar comando TL1 com ID único
|
|
const comandoComId = comando.replace(':1;', `:${this.commandId++};`);
|
|
this.tl1Connection.write(comandoComId + '\r\n');
|
|
|
|
// Timeout para resposta
|
|
setTimeout(() => {
|
|
if (!responseReceived) {
|
|
this.tl1Connection.removeListener('data', dataHandler);
|
|
reject(new Error('Timeout aguardando resposta TL1'));
|
|
}
|
|
}, 10000);
|
|
});
|
|
|
|
} 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');
|
|
}
|
|
|
|
// Comando TL1 para buscar informações da ONU
|
|
const comando = `RTRV-ONU::${serial}: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, serial);
|
|
|
|
this.logger.debug('Status ONU processado via TL1', statusONU);
|
|
|
|
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
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Processar resposta TL1 para status de ONU
|
|
*/
|
|
processarStatusONUTL1(dadosTL1, identificador) {
|
|
try {
|
|
// Processar dados TL1 - formato típico Fiberhome
|
|
// Exemplo de resposta TL1: "COMPLD RTRV-ONU:OLT:ONU-1:1:SERIAL=FHTT12345678,..."
|
|
|
|
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 (!dadosTL1 || typeof dadosTL1 !== 'string') {
|
|
return resultado;
|
|
}
|
|
|
|
// Extrair informações básicas da resposta TL1
|
|
if (dadosTL1.includes('COMPLD')) {
|
|
resultado.online = true;
|
|
|
|
// Extrair serial se disponível
|
|
const serialMatch = dadosTL1.match(/SERIAL=([A-Z0-9]+)/i);
|
|
if (serialMatch) {
|
|
resultado.serial = serialMatch[1];
|
|
}
|
|
|
|
// Extrair device name se disponível
|
|
const deviceMatch = dadosTL1.match(/DEVICENAME=([^,\s]+)/i);
|
|
if (deviceMatch) {
|
|
resultado.deviceName = deviceMatch[1];
|
|
}
|
|
|
|
// Extrair posição (slot/pon/onu)
|
|
const posicaoMatch = dadosTL1.match(/(\d+)-(\d+)-(\d+)/);
|
|
if (posicaoMatch) {
|
|
resultado.slot = posicaoMatch[1];
|
|
resultado.pon = posicaoMatch[2];
|
|
resultado.onuId = posicaoMatch[3];
|
|
}
|
|
|
|
// Extrair informações de sinal
|
|
const rxMatch = dadosTL1.match(/RXPOWER=([^,\s]+)/i);
|
|
if (rxMatch) {
|
|
resultado.rxPower = `${rxMatch[1]} dBm`;
|
|
}
|
|
|
|
const txMatch = dadosTL1.match(/TXPOWER=([^,\s]+)/i);
|
|
if (txMatch) {
|
|
resultado.txPower = `${txMatch[1]} dBm`;
|
|
}
|
|
|
|
const distMatch = dadosTL1.match(/DISTANCE=([^,\s]+)/i);
|
|
if (distMatch) {
|
|
resultado.distance = `${distMatch[1]} m`;
|
|
}
|
|
|
|
// Simular algumas portas Ethernet (dados típicos de ONU)
|
|
resultado.portasEthernet = [
|
|
{ porta: 1, status: 'up' },
|
|
{ porta: 2, status: 'down' },
|
|
{ porta: 3, status: 'down' },
|
|
{ porta: 4, status: 'down' }
|
|
];
|
|
|
|
// Simular serviço WAN
|
|
if (resultado.online) {
|
|
resultado.servicosWAN = [
|
|
{ id: 1, status: 'active', ip: '192.168.1.100' }
|
|
];
|
|
}
|
|
}
|
|
|
|
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: []
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Descobrir porta PON onde a ONU está descoberta
|
|
* @param {string} serial - Serial da ONU (MAC address)
|
|
*/
|
|
async descobrirPortaPON(serial) {
|
|
try {
|
|
console.log('🔍 Descobrindo porta PON para ONU:', serial);
|
|
this.logger.debug('Descobrindo porta PON para ONU', { serial });
|
|
|
|
// Conectar ao UNM2000
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
|
|
let tentativas = 0;
|
|
const maxTentativas = 20; // Limitar a 20 tentativas
|
|
|
|
// Primeiro, tentar listar dispositivos para descobrir o nome correto da OLT
|
|
console.log('📋 Listando dispositivos OLT...');
|
|
const listarCmd = `LST-DEVICE:::${this.commandId++}::;`;
|
|
const dispositivos = await this.executarComandoTL1(listarCmd);
|
|
|
|
let oltName = this.config.olt.name; // Fallback para o IP configurado
|
|
|
|
if (dispositivos.success && dispositivos.data) {
|
|
console.log('📋 Resposta LST-DEVICE:', dispositivos.data);
|
|
|
|
// Extrair DEVNAME da resposta (formato: AN5516-06_172.16.10.6)
|
|
const match = dispositivos.data.match(/^([^\s]+)\s+[\d\.]+\s+AN5516/m);
|
|
if (match && match[1]) {
|
|
oltName = match[1];
|
|
console.log(`✅ Nome da OLT descoberto: ${oltName}`);
|
|
// Atualizar configuração para uso futuro
|
|
this.config.olt.name = oltName;
|
|
} else {
|
|
console.log('⚠️ Não foi possível extrair DEVNAME, usando IP como fallback');
|
|
}
|
|
} else {
|
|
console.log('⚠️ Não foi possível listar dispositivos:', dispositivos.error);
|
|
}
|
|
|
|
// Buscar em todas as portas PON possíveis (slots 1-20, portas 1-16)
|
|
for (let slot = 1; slot <= 20 && tentativas < maxTentativas; slot++) {
|
|
for (let porta = 1; porta <= 16 && tentativas < maxTentativas; porta++) {
|
|
tentativas++;
|
|
const ponId = `NA-NA-${slot}-${porta}`;
|
|
const comando = `LST-UNREGONU::OLTID=${oltName},PONID=${ponId}:${this.commandId++}::;`;
|
|
|
|
console.log(`🔎 Consultando porta PON ${ponId} (tentativa ${tentativas}/${maxTentativas})`);
|
|
this.logger.debug('Consultando porta PON', { ponId, tentativa: tentativas, oltName });
|
|
const resultado = await this.executarComandoTL1(comando);
|
|
|
|
if (resultado.success && resultado.data) {
|
|
// Verificar se a ONU está na resposta
|
|
if (resultado.data.toUpperCase().includes(serial.toUpperCase())) {
|
|
console.log(`✅ Porta PON descoberta: ${ponId}`);
|
|
this.logger.info('Porta PON descoberta', { serial, ponId });
|
|
return {
|
|
success: true,
|
|
portAlias: `${slot}-${porta}`,
|
|
slot,
|
|
porta
|
|
};
|
|
}
|
|
} else if (!resultado.success) {
|
|
console.log(`⚠️ Erro ao consultar porta ${ponId}: ${resultado.error}`);
|
|
// Se o erro for de formato, provavelmente todas as portas vão falhar
|
|
if (resultado.error && resultado.error.includes('invalid parameter format')) {
|
|
console.log('❌ Formato de comando inválido, interrompendo busca');
|
|
throw new Error('Formato de comando LST-UNREGONU inválido. Verifique configuração da OLT.');
|
|
}
|
|
}
|
|
|
|
// Pequeno delay entre consultas para não sobrecarregar
|
|
await new Promise(resolve => setTimeout(resolve, 200));
|
|
}
|
|
}
|
|
|
|
// ONU não encontrada
|
|
console.log(`❌ ONU ${serial} não encontrada após ${tentativas} tentativas`);
|
|
this.logger.warn('ONU não encontrada em nenhuma porta PON', { serial, tentativas });
|
|
return {
|
|
success: false,
|
|
error: 'ONU não encontrada em nenhuma porta PON. Verifique se a ONU está ligada e descoberta pela OLT.'
|
|
};
|
|
|
|
} catch (error) {
|
|
console.log('❌ Erro ao descobrir porta PON:', error.message);
|
|
this.logger.error('Erro ao descobrir porta PON', { serial, error: error.message });
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adicionar ONU Fiberhome via TL1
|
|
* @param {string} serial - Serial da ONU (MAC address)
|
|
* @param {string} usuario - Nome/alias do usuário
|
|
* @param {number} vlan - VLAN ID (padrão: 1002)
|
|
* @param {string} onuType - Tipo da ONU (AN5506-02-B ou AN5506-01-A)
|
|
*/
|
|
async adicionarOnuFiberhome(serial, usuario, vlan = 1002, onuType = 'AN5506-02-B') {
|
|
try {
|
|
this.logger.info('Iniciando adição de ONU Fiberhome via TL1', {
|
|
serial, usuario, vlan, onuType
|
|
});
|
|
|
|
// Conectar ao UNM2000
|
|
const conectado = await this.conectarUNM2000();
|
|
if (!conectado) {
|
|
throw new Error('Não foi possível conectar ao UNM2000');
|
|
}
|
|
|
|
// Descobrir porta PON automaticamente
|
|
const descoberta = await this.descobrirPortaPON(serial);
|
|
if (!descoberta.success) {
|
|
throw new Error(descoberta.error);
|
|
}
|
|
|
|
const portAlias = descoberta.portAlias;
|
|
const nameOlt = this.config.olt.name;
|
|
|
|
this.logger.info('Porta PON descoberta', { portAlias, nameOlt });
|
|
|
|
// 1. ADD-ONU: Autenticar a ONU
|
|
const addOnuCmd = `ADD-ONU::OLTID=${nameOlt},PONID=NA-NA-${portAlias}:${this.commandId++}::AUTHTYPE=MAC,ONUTYPE=${onuType},NAME=${usuario},ONUID=${serial};`;
|
|
this.logger.debug('Executando ADD-ONU', { comando: addOnuCmd });
|
|
|
|
const resultadoAdd = await this.executarComandoTL1(addOnuCmd);
|
|
if (!resultadoAdd.success) {
|
|
throw new Error(`Falha ao adicionar ONU: ${resultadoAdd.error}`);
|
|
}
|
|
|
|
// Aguardar um pouco para a ONU ser registrada
|
|
await new Promise(resolve => setTimeout(resolve, 2000));
|
|
|
|
// 2. SET-WANSERVICE: Configurar WAN services
|
|
// Determina quantas portas configurar baseado no tipo da ONU
|
|
const numPortas = onuType === 'AN5506-02-B' ? 2 : 1;
|
|
|
|
for (let porta = 1; porta <= numPortas; porta++) {
|
|
const setWanCmd = `SET-WANSERVICE::OLTID=${nameOlt},PONID=NA-NA-${portAlias},ONUIDTYPE=MAC,ONUID=${serial}:${this.commandId++}::STATUS=1,MODE=2,CONNTYPE=1,VLAN=${vlan},COS=0,QOS=2,UPORT=${porta};`;
|
|
this.logger.debug(`Configurando WAN Service porta ${porta}`, { comando: setWanCmd });
|
|
|
|
const resultadoWan = await this.executarComandoTL1(setWanCmd);
|
|
if (!resultadoWan.success) {
|
|
this.logger.warn(`Aviso ao configurar WAN porta ${porta}: ${resultadoWan.error}`);
|
|
// Não lança erro, apenas registra o aviso
|
|
}
|
|
|
|
// Pequeno delay entre comandos
|
|
await new Promise(resolve => setTimeout(resolve, 1000));
|
|
}
|
|
|
|
// 3. CFG-WEBADMINISTRATOR: Configurar autenticação web
|
|
const cfgWebCmd = `CFG-WEBADMINISTRATOR::OLTID=${nameOlt},PONID=NA-NA-${portAlias},ONUIDTYPE=MAC,ONUID=${serial}:${this.commandId++}::WEBUSERNAME=admin,WEBPASSWORD=clicknet10;`;
|
|
this.logger.debug('Configurando autenticação web', { comando: cfgWebCmd });
|
|
|
|
const resultadoWeb = await this.executarComandoTL1(cfgWebCmd);
|
|
if (!resultadoWeb.success) {
|
|
this.logger.warn(`Aviso ao configurar autenticação web: ${resultadoWeb.error}`);
|
|
// Não lança erro, apenas registra o aviso
|
|
}
|
|
|
|
// Aguardar antes de reiniciar
|
|
await new Promise(resolve => setTimeout(resolve, 2000));
|
|
|
|
// 4. RESET-ONU: Reiniciar a ONU
|
|
const resetCmd = `RESET-ONU::OLTID=${nameOlt},PONID=NA-NA-${portAlias},ONUIDTYPE=MAC,ONUID=${serial}:${this.commandId++}::;`;
|
|
this.logger.debug('Reiniciando ONU', { comando: resetCmd });
|
|
|
|
const resultadoReset = await this.executarComandoTL1(resetCmd);
|
|
if (!resultadoReset.success) {
|
|
this.logger.warn(`Aviso ao reiniciar ONU: ${resultadoReset.error}`);
|
|
// Não lança erro, apenas registra o aviso
|
|
}
|
|
|
|
this.logger.info('ONU Fiberhome adicionada com sucesso', {
|
|
nameOlt, portAlias, serial, usuario, vlan
|
|
});
|
|
|
|
return {
|
|
success: true,
|
|
message: 'ONU adicionada com sucesso',
|
|
details: {
|
|
olt: nameOlt,
|
|
porta: portAlias,
|
|
slot: descoberta.slot,
|
|
ponPort: descoberta.porta,
|
|
serial: serial,
|
|
usuario: usuario,
|
|
vlan: vlan,
|
|
tipo: onuType,
|
|
portas: numPortas
|
|
}
|
|
};
|
|
|
|
} catch (error) {
|
|
this.logger.error('Erro ao adicionar ONU Fiberhome', {
|
|
serial, error: error.message
|
|
});
|
|
return {
|
|
success: false,
|
|
error: error.message
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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;
|