425 lines
15 KiB
JavaScript
425 lines
15 KiB
JavaScript
"use strict";
|
|
// =====================================================
|
|
// 資料庫備援連線服務
|
|
// =====================================================
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.dbFailover = exports.DatabaseFailover = void 0;
|
|
const promise_1 = __importDefault(require("mysql2/promise"));
|
|
// 主機資料庫配置
|
|
const masterConfig = {
|
|
host: process.env.DB_HOST || 'mysql.theaken.com',
|
|
port: parseInt(process.env.DB_PORT || '33306'),
|
|
user: process.env.DB_USER || 'AI_Platform',
|
|
password: process.env.DB_PASSWORD || 'Aa123456',
|
|
database: process.env.DB_NAME || 'db_AI_Platform',
|
|
charset: 'utf8mb4',
|
|
timezone: '+08:00',
|
|
connectionLimit: 10,
|
|
queueLimit: 0,
|
|
idleTimeout: 300000,
|
|
ssl: false,
|
|
};
|
|
// 備機資料庫配置
|
|
const slaveConfig = {
|
|
host: process.env.SLAVE_DB_HOST || '122.100.99.161',
|
|
port: parseInt(process.env.SLAVE_DB_PORT || '43306'),
|
|
user: process.env.SLAVE_DB_USER || 'A999',
|
|
password: process.env.SLAVE_DB_PASSWORD || '1023',
|
|
database: process.env.SLAVE_DB_NAME || 'db_AI_Platform', // 修正為 AI 平台資料庫
|
|
charset: 'utf8mb4',
|
|
timezone: '+08:00',
|
|
connectionLimit: 10,
|
|
queueLimit: 0,
|
|
idleTimeout: 300000,
|
|
ssl: false,
|
|
};
|
|
// 備援資料庫管理類
|
|
class DatabaseFailover {
|
|
constructor() {
|
|
this.masterPool = null;
|
|
this.slavePool = null;
|
|
this.healthCheckInterval = null;
|
|
this.status = {
|
|
isEnabled: process.env.DB_FAILOVER_ENABLED === 'true',
|
|
currentDatabase: 'master',
|
|
masterHealthy: false,
|
|
slaveHealthy: false,
|
|
lastHealthCheck: 0,
|
|
consecutiveFailures: 0,
|
|
};
|
|
// 同步初始化連接池
|
|
this.initializePoolsSync();
|
|
this.startHealthCheck();
|
|
}
|
|
static getInstance() {
|
|
if (!DatabaseFailover.instance) {
|
|
DatabaseFailover.instance = new DatabaseFailover();
|
|
}
|
|
return DatabaseFailover.instance;
|
|
}
|
|
// 同步初始化連接池
|
|
initializePoolsSync() {
|
|
try {
|
|
console.log('🚀 開始同步初始化資料庫備援系統...');
|
|
// 直接創建連接池，不等待測試
|
|
this.masterPool = promise_1.default.createPool(masterConfig);
|
|
console.log('✅ 主機資料庫連接池創建成功');
|
|
this.slavePool = promise_1.default.createPool(slaveConfig);
|
|
console.log('✅ 備機資料庫連接池創建成功');
|
|
// 設置默認使用主機
|
|
this.status.currentDatabase = 'master';
|
|
this.status.masterHealthy = true; // 假設主機健康，後續健康檢查會驗證
|
|
console.log('🎯 當前使用資料庫: 主機');
|
|
// 異步測試連接
|
|
this.testConnectionsAsync();
|
|
}
|
|
catch (error) {
|
|
console.error('❌ 資料庫連接池同步初始化失敗:', error);
|
|
}
|
|
}
|
|
// 異步測試連接
|
|
async testConnectionsAsync() {
|
|
try {
|
|
await this.testConnections();
|
|
}
|
|
catch (error) {
|
|
console.error('❌ 異步連接測試失敗:', error);
|
|
}
|
|
}
|
|
// 初始化連接池
|
|
async initializePools() {
|
|
try {
|
|
console.log('🚀 開始初始化資料庫備援系統...');
|
|
// 先測試主機連接
|
|
console.log('📡 測試主機資料庫連接...');
|
|
const masterHealthy = await this.testMasterConnection();
|
|
if (masterHealthy) {
|
|
console.log('✅ 主機資料庫連接正常，使用主機');
|
|
this.status.currentDatabase = 'master';
|
|
this.status.masterHealthy = true;
|
|
// 初始化主機連接池
|
|
this.masterPool = promise_1.default.createPool(masterConfig);
|
|
console.log('✅ 主機資料庫連接池初始化成功');
|
|
}
|
|
else {
|
|
console.log('❌ 主機資料庫連接失敗，測試備機...');
|
|
// 測試備機連接
|
|
const slaveHealthy = await this.testSlaveConnection();
|
|
if (slaveHealthy) {
|
|
console.log('✅ 備機資料庫連接正常，切換到備機');
|
|
this.status.currentDatabase = 'slave';
|
|
this.status.slaveHealthy = true;
|
|
// 初始化備機連接池
|
|
this.slavePool = promise_1.default.createPool(slaveConfig);
|
|
console.log('✅ 備機資料庫連接池初始化成功');
|
|
}
|
|
else {
|
|
console.log('❌ 主機和備機都無法連接，嘗試初始化主機連接池');
|
|
this.masterPool = promise_1.default.createPool(masterConfig);
|
|
this.status.currentDatabase = 'master';
|
|
}
|
|
}
|
|
// 初始化另一個連接池（用於健康檢查）
|
|
if (this.status.currentDatabase === 'master' && !this.slavePool) {
|
|
this.slavePool = promise_1.default.createPool(slaveConfig);
|
|
console.log('✅ 備機資料庫連接池初始化成功（用於健康檢查）');
|
|
}
|
|
else if (this.status.currentDatabase === 'slave' && !this.masterPool) {
|
|
this.masterPool = promise_1.default.createPool(masterConfig);
|
|
console.log('✅ 主機資料庫連接池初始化成功（用於健康檢查）');
|
|
}
|
|
console.log(`🎯 當前使用資料庫: ${this.status.currentDatabase === 'master' ? '主機' : '備機'}`);
|
|
}
|
|
catch (error) {
|
|
console.error('❌ 資料庫連接池初始化失敗:', error);
|
|
}
|
|
}
|
|
// 測試主機連接
|
|
async testMasterConnection() {
|
|
try {
|
|
const connection = await promise_1.default.createConnection(masterConfig);
|
|
await connection.ping();
|
|
await connection.end();
|
|
return true;
|
|
}
|
|
catch (error) {
|
|
console.error('主機資料庫連接失敗:', error.message);
|
|
return false;
|
|
}
|
|
}
|
|
// 測試備機連接
|
|
async testSlaveConnection() {
|
|
try {
|
|
const connection = await promise_1.default.createConnection(slaveConfig);
|
|
await connection.ping();
|
|
await connection.end();
|
|
return true;
|
|
}
|
|
catch (error) {
|
|
console.error('備機資料庫連接失敗:', error.message);
|
|
return false;
|
|
}
|
|
}
|
|
// 測試資料庫連接
|
|
async testConnections() {
|
|
// 測試主機
|
|
try {
|
|
if (this.masterPool) {
|
|
const connection = await this.masterPool.getConnection();
|
|
await connection.ping();
|
|
connection.release();
|
|
this.status.masterHealthy = true;
|
|
console.log('主機資料庫連接正常');
|
|
}
|
|
}
|
|
catch (error) {
|
|
this.status.masterHealthy = false;
|
|
console.error('主機資料庫連接失敗:', error);
|
|
}
|
|
// 測試備機
|
|
try {
|
|
if (this.slavePool) {
|
|
const connection = await this.slavePool.getConnection();
|
|
await connection.ping();
|
|
connection.release();
|
|
this.status.slaveHealthy = true;
|
|
console.log('備機資料庫連接正常');
|
|
}
|
|
}
|
|
catch (error) {
|
|
this.status.slaveHealthy = false;
|
|
console.error('備機資料庫連接失敗:', error);
|
|
}
|
|
}
|
|
// 開始健康檢查
|
|
startHealthCheck() {
|
|
if (!this.status.isEnabled)
|
|
return;
|
|
const interval = parseInt(process.env.DB_HEALTH_CHECK_INTERVAL || '30000');
|
|
this.healthCheckInterval = setInterval(async () => {
|
|
await this.performHealthCheck();
|
|
}, interval);
|
|
}
|
|
// 執行健康檢查
|
|
async performHealthCheck() {
|
|
const now = Date.now();
|
|
this.status.lastHealthCheck = now;
|
|
// 檢查主機
|
|
if (this.masterPool) {
|
|
try {
|
|
const connection = await this.masterPool.getConnection();
|
|
await connection.ping();
|
|
connection.release();
|
|
this.status.masterHealthy = true;
|
|
}
|
|
catch (error) {
|
|
this.status.masterHealthy = false;
|
|
console.error('主機資料庫健康檢查失敗:', error);
|
|
}
|
|
}
|
|
// 檢查備機
|
|
if (this.slavePool) {
|
|
try {
|
|
const connection = await this.slavePool.getConnection();
|
|
await connection.ping();
|
|
connection.release();
|
|
this.status.slaveHealthy = true;
|
|
}
|
|
catch (error) {
|
|
this.status.slaveHealthy = false;
|
|
console.error('備機資料庫健康檢查失敗:', error);
|
|
}
|
|
}
|
|
// 決定當前使用的資料庫
|
|
this.determineCurrentDatabase();
|
|
}
|
|
// 決定當前使用的資料庫
|
|
determineCurrentDatabase() {
|
|
const previousDatabase = this.status.currentDatabase;
|
|
if (this.status.masterHealthy) {
|
|
if (this.status.currentDatabase !== 'master') {
|
|
console.log('🔄 主機資料庫恢復，切換回主機');
|
|
this.status.currentDatabase = 'master';
|
|
this.status.consecutiveFailures = 0;
|
|
}
|
|
}
|
|
else if (this.status.slaveHealthy) {
|
|
if (this.status.currentDatabase !== 'slave') {
|
|
console.log('🔄 主機資料庫故障，切換到備機');
|
|
this.status.currentDatabase = 'slave';
|
|
this.status.consecutiveFailures++;
|
|
}
|
|
}
|
|
else {
|
|
this.status.consecutiveFailures++;
|
|
console.error('❌ 主機和備機資料庫都無法連接');
|
|
}
|
|
// 記錄狀態變化
|
|
if (previousDatabase !== this.status.currentDatabase) {
|
|
console.log(`📊 資料庫狀態變化: ${previousDatabase} → ${this.status.currentDatabase}`);
|
|
}
|
|
}
|
|
// 獲取當前連接池
|
|
getCurrentPool() {
|
|
if (this.status.currentDatabase === 'master') {
|
|
if (this.masterPool) {
|
|
return this.masterPool;
|
|
}
|
|
else if (this.slavePool) {
|
|
// 主機不可用，嘗試使用備機
|
|
console.log('⚠️ 主機連接池不可用，嘗試使用備機');
|
|
this.status.currentDatabase = 'slave';
|
|
return this.slavePool;
|
|
}
|
|
}
|
|
else if (this.status.currentDatabase === 'slave') {
|
|
if (this.slavePool) {
|
|
return this.slavePool;
|
|
}
|
|
else if (this.masterPool) {
|
|
// 備機不可用，嘗試使用主機
|
|
console.log('⚠️ 備機連接池不可用，嘗試使用主機');
|
|
this.status.currentDatabase = 'master';
|
|
return this.masterPool;
|
|
}
|
|
}
|
|
console.error('❌ 沒有可用的資料庫連接池');
|
|
return null;
|
|
}
|
|
// 獲取連接
|
|
async getConnection() {
|
|
const pool = this.getCurrentPool();
|
|
if (!pool) {
|
|
throw new Error('沒有可用的資料庫連接');
|
|
}
|
|
let retries = 0;
|
|
const maxRetries = parseInt(process.env.DB_RETRY_ATTEMPTS || '3');
|
|
const retryDelay = parseInt(process.env.DB_RETRY_DELAY || '2000');
|
|
while (retries < maxRetries) {
|
|
try {
|
|
return await pool.getConnection();
|
|
}
|
|
catch (error) {
|
|
console.error(`資料庫連接失敗 (嘗試 ${retries + 1}/${maxRetries}):`, error.message);
|
|
if (error.code === 'ECONNRESET' || error.code === 'PROTOCOL_CONNECTION_LOST') {
|
|
// 觸發健康檢查
|
|
await this.performHealthCheck();
|
|
retries++;
|
|
if (retries < maxRetries) {
|
|
console.log(`等待 ${retryDelay}ms 後重試...`);
|
|
await new Promise(resolve => setTimeout(resolve, retryDelay));
|
|
continue;
|
|
}
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
throw new Error('資料庫連接失敗，已達到最大重試次數');
|
|
}
|
|
// 執行查詢
|
|
async query(sql, params) {
|
|
const connection = await this.getConnection();
|
|
try {
|
|
const [rows] = await connection.execute(sql, params);
|
|
return rows;
|
|
}
|
|
finally {
|
|
connection.release();
|
|
}
|
|
}
|
|
// 執行單一查詢
|
|
async queryOne(sql, params) {
|
|
try {
|
|
const results = await this.query(sql, params);
|
|
return results.length > 0 ? results[0] : null;
|
|
}
|
|
catch (error) {
|
|
console.error('資料庫單一查詢錯誤:', error);
|
|
throw error;
|
|
}
|
|
}
|
|
// 執行插入
|
|
async insert(sql, params) {
|
|
const connection = await this.getConnection();
|
|
try {
|
|
const [result] = await connection.execute(sql, params);
|
|
return result;
|
|
}
|
|
finally {
|
|
connection.release();
|
|
}
|
|
}
|
|
// 執行更新
|
|
async update(sql, params) {
|
|
const connection = await this.getConnection();
|
|
try {
|
|
const [result] = await connection.execute(sql, params);
|
|
return result;
|
|
}
|
|
finally {
|
|
connection.release();
|
|
}
|
|
}
|
|
// 執行刪除
|
|
async delete(sql, params) {
|
|
const connection = await this.getConnection();
|
|
try {
|
|
const [result] = await connection.execute(sql, params);
|
|
return result;
|
|
}
|
|
finally {
|
|
connection.release();
|
|
}
|
|
}
|
|
// 開始事務
|
|
async beginTransaction() {
|
|
const connection = await this.getConnection();
|
|
await connection.beginTransaction();
|
|
return connection;
|
|
}
|
|
// 提交事務
|
|
async commit(connection) {
|
|
await connection.commit();
|
|
connection.release();
|
|
}
|
|
// 回滾事務
|
|
async rollback(connection) {
|
|
await connection.rollback();
|
|
connection.release();
|
|
}
|
|
// 獲取備援狀態
|
|
getStatus() {
|
|
return { ...this.status };
|
|
}
|
|
// 強制切換到指定資料庫
|
|
async switchToDatabase(database) {
|
|
if (database === 'master' && this.status.masterHealthy) {
|
|
this.status.currentDatabase = 'master';
|
|
return true;
|
|
}
|
|
else if (database === 'slave' && this.status.slaveHealthy) {
|
|
this.status.currentDatabase = 'slave';
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
// 關閉所有連接池
|
|
async close() {
|
|
if (this.healthCheckInterval) {
|
|
clearInterval(this.healthCheckInterval);
|
|
}
|
|
if (this.masterPool) {
|
|
await this.masterPool.end();
|
|
}
|
|
if (this.slavePool) {
|
|
await this.slavePool.end();
|
|
}
|
|
}
|
|
}
|
|
exports.DatabaseFailover = DatabaseFailover;
|
|
// 導出單例實例
|
|
exports.dbFailover = DatabaseFailover.getInstance();
|