Oracle Conexão simultânea ao Oracle (Uma página derrubando outra)

Fabio Eduardo Argenton · 26 de setembro

Tenho uma alicação WEB desenvolvida em Node.JS essa aplicação consome dados de um BD Oracle e a aplicação roda em rede interna da empresa.

Está tudo funcionando perfeitamente, execto quando mais de uma página é carregada simultaneamente num mesm cliente desktop ou em clientes desktop distintos.

Caso eu abra uma página, ela carrega por completo sem problemas, caso eu abra uma página e em seguida abra uma segunda página sempre a página aberta mais recente carrega, a anterior perde a conexão com o oracle e acaba não renderizando os dados na tela.

Abaixo trechos relevantes do meu código.

Arquivo configOracle.js é onde tenho a string de conexão:

const oracledb = require('oracledb');

let pool; // Declare a variável do pool fora da função

async function initializePool() {
    pool = await oracledb.createPool({
        user: 'meu_user', // seu usuário
        password: 'minha_senha', // sua senha
        connectString: '//172.17.0.21:1523/SPW', // string de conexão
        poolMin: 10, // mínimo de conexões
        poolMax: 20, // máximo de conexões
        poolIncrement: 5, // número de conexões a serem criadas quando necessário
    });
    console.log('Pool de conexões criado com sucesso.');
}

const configOracle = {
    getConnectionWithRetry: async (retries = 5) => {
        for (let i = 0; i < retries; i++) {
            try {
                const connection = await pool.getConnection(); // Obtém uma conexão do pool
                return connection;
            } catch (err) {
                console.error(`Erro ao obter a conexão do Oracle (tentativa ${i + 1}/${retries}):`, err);
                if (i === retries - 1) throw err; // Lança o erro após esgotar as tentativas
                await new Promise(resolve => setTimeout(resolve, 1000)); // Aguarda 1 segundo antes da próxima tentativa
            }
        }
    },

    getConnection: async () => {
        return configOracle.getConnectionWithRetry(); // Apenas reutiliza a função de retry
    },

    closeConnection: async (connection) => {
        if (connection) {
            try {
                await connection.close(); // Fecha a conexão, retornando-a ao pool
                console.log('Conexão Oracle fechada com sucesso.');
            } catch (err) {
                console.error('Erro ao fechar a conexão Oracle:', err);
                throw err;
            }
        }
    }
};


// Chame a função de inicialização do pool
initializePool().catch(err => {
    console.error('Erro ao inicializar o pool de conexões:', err);
});

module.exports = configOracle;

Nos arquivos que renderizam as páginas tenho o seguinte (somente trecho relevantes):

// Conexão Oracle
const DBOracle = require('../listas/selectsOracle');
const configOracle = require('../../database/configOracle'); // Atualizado para o novo configOracle

const FUNCOES = require('../util/funcoes');
const moment = require('moment');

module.exports = {
    pageDASHProducao: async (req, res) => {
        const connection = await configOracle.getConnection();

        try {

            // Passar a conexão para a classe DBModelOracle
            let DBModelOracle = new DBOracle(connection);
.
.
.

e ao final quando carrega a página, fecha a conexão:

.
.
.
});
        } catch (err) {
            console.error('Erro ao conectar ao banco de dados:', err);
            res.status(500).send('Erro interno no servidor');
        } finally {
            // Fechando a conexão individual
            await configOracle.closeConnection(connection); // Fecha a conexão após o uso
        }
    },
};