dnsRecordsSyncWorker.js

Go to the documentation of this file.

/**
 * DNS Records Sync Worker
 * Syncs DNS records from Cloudflare to Redis cache every 5 minutes
 * Provides fast page loads and reduces Cloudflare API calls
 * Cache is invalidated when users edit DNS records for instant updates
 */
 
const Redis = require('ioredis');
const pool = require('./db');
const { listDNSRecords } = require('./services/cloudflare');
 
const redisConfig = require('./config/redis');
let redisClient = null;
 
const SYNC_INTERVAL = 5 * 60 * 1000; // 5 minutes
const REDIS_KEY_PREFIX_RECORDS = 'dns:records:';
const REDIS_KEY_PREFIX_SYNC = 'dns:sync:';
const API_DELAY = 500; // Delay between API calls to avoid rate limiting
 
/**
 * Initialize Redis connection
 */
function initRedis() {
  if (!redisClient) {
    redisClient = new Redis({
      ...redisConfig,
      maxRetriesPerRequest: null,
      lazyConnect: true
    });
 
    redisClient.on('error', (err) => {
      console.error('[DNS Sync] Redis error:', err.message);
    });
 
    redisClient.on('connect', () => {
      console.log('[DNS Sync] Redis connected');
    });
  }
  return redisClient.connect().catch(err => {
    console.error('[DNS Sync] Redis connection failed:', err.message);
  });
}
 
/**
 * Get all domains with Cloudflare zone IDs from database
 */
async function getDomainsWithZones() {
  try {
    const result = await pool.query(`
      SELECT 
        domain_name,
        COALESCE(
          registrar_domain_id,
          metadata->>'zone_id',
          metadata->>'cloudflare_zone_id'
        ) as zone_id
      FROM domains
      WHERE 
        (registrar = 'cloudflare' OR metadata->>'has_cloudflare_dns' = 'true')
        AND (
          registrar_domain_id IS NOT NULL 
          OR metadata->>'zone_id' IS NOT NULL
          OR metadata->>'cloudflare_zone_id' IS NOT NULL
        )
      ORDER BY domain_name
    `);
    
    return result.rows.filter(row => row.zone_id);
  } catch (error) {
    console.error('[DNS Sync] Error fetching domains:', error.message);
    return [];
  }
}
 
/**
 * Sync DNS records for a single domain
 * @param domain
 * @param zoneId
 */
async function syncDomainRecords(domain, zoneId) {
  try {
    const records = await listDNSRecords(zoneId);
    
    if (!records || records.length === 0) {
      console.log(`[DNS Sync] ${domain}: No DNS records found`);
      return { domain, records: [], error: null };
    }
 
    // Store records in Redis
    const recordsKey = REDIS_KEY_PREFIX_RECORDS + domain;
    const syncKey = REDIS_KEY_PREFIX_SYNC + domain;
    const timestamp = new Date().toISOString();
 
    await redisClient.setex(
      recordsKey,
      SYNC_INTERVAL * 2, // 10 minutes TTL (2x sync interval for safety)
      JSON.stringify(records)
    );
 
    await redisClient.setex(
      syncKey,
      SYNC_INTERVAL * 2,
      timestamp
    );
 
    console.log(`[DNS Sync] ${domain}: Cached ${records.length} records`);
    return { domain, records, error: null };
  } catch (error) {
    console.error(`[DNS Sync] ${domain}: Error syncing records:`, error.message);
    return { domain, records: [], error: error.message };
  }
}
 
/**
 * Sync all DNS records
 */
async function syncAllDNSRecords() {
  const startTime = Date.now();
  console.log('[DNS Sync] Starting DNS records sync...');
 
  try {
    // Get all domains with Cloudflare zones
    const domains = await getDomainsWithZones();
    
    if (domains.length === 0) {
      console.log('[DNS Sync] No domains with Cloudflare zones found');
      return;
    }
 
    console.log(`[DNS Sync] Found ${domains.length} domains with Cloudflare zones`);
 
    let successCount = 0;
    let errorCount = 0;
    let totalRecords = 0;
 
    // Sync each domain with rate limiting
    for (const { domain_name, zone_id } of domains) {
      // Rate limiting delay
      await new Promise(resolve => setTimeout(resolve, API_DELAY));
 
      const result = await syncDomainRecords(domain_name, zone_id);
      
      if (result.error) {
        errorCount++;
      } else {
        successCount++;
        totalRecords += result.records.length;
      }
    }
 
    const elapsed = Date.now() - startTime;
    console.log(`[DNS Sync] Completed: ${successCount} domains synced, ${errorCount} errors, ${totalRecords} total records (${elapsed}ms)`);
  } catch (error) {
    console.error('[DNS Sync] Sync error:', error);
  }
}
 
/**
 * Get cached DNS records for a domain
 * Returns null if not in cache
 * @param domain
 */
async function getCachedDNSRecords(domain) {
  if (!redisClient) {
    await initRedis();
  }
 
  try {
    const recordsKey = REDIS_KEY_PREFIX_RECORDS + domain;
    const syncKey = REDIS_KEY_PREFIX_SYNC + domain;
 
    const [recordsJson, syncTime] = await Promise.all([
      redisClient.get(recordsKey),
      redisClient.get(syncKey)
    ]);
 
    if (!recordsJson) {
      return null;
    }
 
    return {
      records: JSON.parse(recordsJson),
      last_synced: syncTime
    };
  } catch (error) {
    console.error(`[DNS Sync] Error getting cached records for ${domain}:`, error.message);
    return null;
  }
}
 
/**
 * Invalidate cache for a domain (call this after DNS edits)
 * @param domain
 */
async function invalidateDNSCache(domain) {
  if (!redisClient) {
    await initRedis();
  }
 
  try {
    const recordsKey = REDIS_KEY_PREFIX_RECORDS + domain;
    const syncKey = REDIS_KEY_PREFIX_SYNC + domain;
 
    await Promise.all([
      redisClient.del(recordsKey),
      redisClient.del(syncKey)
    ]);
 
    console.log(`[DNS Sync] Cache invalidated for ${domain}`);
  } catch (error) {
    console.error(`[DNS Sync] Error invalidating cache for ${domain}:`, error.message);
  }
}
 
/**
 * Start the DNS sync worker
 */
function startDNSSyncWorker() {
  console.log(`[DNS Sync] Worker started - syncing every ${SYNC_INTERVAL / 1000 / 60} minutes`);
  console.log('[DNS Sync] Architecture:');
  console.log('[DNS Sync]   1. Fetch DNS records from Cloudflare for all domains');
  console.log('[DNS Sync]   2. Cache records in Redis (10 min TTL)');
  console.log('[DNS Sync]   3. DNS edits invalidate cache for instant updates');
  
  // Initialize Redis and run first sync
  initRedis()
    .then(() => {
      console.log('[DNS Sync] Running initial DNS sync...');
      return syncAllDNSRecords();
    })
    .then(() => {
      // Schedule periodic sync
      setInterval(syncAllDNSRecords, SYNC_INTERVAL);
      console.log('[DNS Sync] Periodic DNS sync scheduled');
    })
    .catch(err => {
      console.error('[DNS Sync] Startup error:', err);
    });
}
 
// Start the worker if this file is run directly
if (require.main === module) {
  startDNSSyncWorker();
}
 
module.exports = { 
  startDNSSyncWorker, 
  syncAllDNSRecords,
  getCachedDNSRecords,
  invalidateDNSCache 
};