tenant-meshcentral-sync.js

Go to the documentation of this file.

/**
 * Startup Tenant-MeshCentral Sync
 * 
 * Automatically runs on backend startup to ensure all tenants
 * have device groups in MeshCentral. Now that MeshCentral uses
 * PostgreSQL, mesh groups persist across restarts.
 * 
 * Process:
 * 1. Fetch all tenants from PostgreSQL database
 * 2. Fetch all existing mesh groups from MeshCentral
 * 3. Match tenants to mesh groups by ID or name
 * 4. Create missing mesh groups for any unmatched tenants
 * 5. Tag all devices in each mesh with tenant UUID
 */
 
const db = require('../db');
const MeshCentralAPI = require('../lib/meshcentral-api');
 
const MESHCENTRAL_URL = process.env.MESHCENTRAL_URL || 'https://rmm-psa-meshcentral-aq48h.ondigitalocean.app';
const MESHCENTRAL_USER = process.env.MESHCENTRAL_ADMIN_USER || 'admin';
const MESHCENTRAL_PASSWORD = process.env.MESHCENTRAL_ADMIN_PASS || 'admin';
 
// Delay before running sync (to let MeshCentral start up)
const STARTUP_DELAY = parseInt(process.env.TENANT_SYNC_DELAY || '30000'); // 30 seconds
 
/**
 * Ensure tenant has a device group in MeshCentral
 * Matches existing groups by ID or name, creates new ones if needed
 * @param api
 * @param tenant
 * @param existingMeshes
 */
async function ensureTenantMesh(api, tenant, existingMeshes) {
  try {
    const expectedMeshName = `${tenant.name} Devices`;
    
    // Check if tenant already has a mesh ID
    if (tenant.meshcentral_group_id) {
      // Verify it still exists in MeshCentral
      const meshExists = existingMeshes.some(m => m._id === tenant.meshcentral_group_id);
      
      if (meshExists) {
        console.log(`  ✅ Tenant "${tenant.name}" has mesh: ${tenant.meshcentral_group_id}`);
        await tagDevicesInMesh(api, tenant);
        return { meshId: tenant.meshcentral_group_id, created: false, linked: false };
      } else {
        console.log(`  ⚠️  Tenant "${tenant.name}" mesh ${tenant.meshcentral_group_id} not found`);
        // Continue to try finding by name or create new
      }
    }
    
    // Try to find existing mesh by name
    const matchingMesh = existingMeshes.find(m => {
      const meshName = m.name || '';
      return meshName === expectedMeshName || 
             meshName === tenant.name || 
             meshName.includes(tenant.name);
    });
    
    if (matchingMesh) {
      console.log(`  🔗 Found existing mesh "${matchingMesh.name}" - linking to tenant "${tenant.name}"`);
      
      // Link this mesh to the tenant
      await db.query(
        'UPDATE tenants SET meshcentral_group_id = $1, meshcentral_setup_complete = true WHERE tenant_id = $2',
        [matchingMesh._id, tenant.tenant_id]
      );
      
      console.log(`  ✅ Linked mesh ${matchingMesh._id} to tenant "${tenant.name}"`);
      await tagDevicesInMesh(api, { ...tenant, meshcentral_group_id: matchingMesh._id });
      
      return { meshId: matchingMesh._id, created: false, linked: true };
    }
    
    // No existing mesh found - create new one
    console.log(`  📦 Creating new mesh: ${expectedMeshName}`);
    
    const result = await api.createMesh(expectedMeshName, `Device group for ${tenant.name} (tenant:${tenant.tenant_id})`);
    
    if (!result || !result.meshId) {
      throw new Error('Failed to create mesh in MeshCentral');
    }
    
    // Store mesh ID in database
    await db.query(
      'UPDATE tenants SET meshcentral_group_id = $1, meshcentral_setup_complete = true WHERE tenant_id = $2',
      [result.meshId, tenant.tenant_id]
    );
    
    console.log(`  ✅ Created mesh ${result.meshId} for "${tenant.name}"`);
    
    return { meshId: result.meshId, created: true, linked: false };
    
  } catch (error) {
    console.error(`  ❌ Error for tenant "${tenant.name}":`, error.message);
    throw error;
  }
}
 
/**
 * Tag all devices in a mesh with tenant UUID
 * @param api
 * @param tenant
 */
async function tagDevicesInMesh(api, tenant) {
  try {
    const nodes = await api.getNodes();
    const meshNodes = nodes.filter(n => n.meshid === tenant.meshcentral_group_id);
    
    if (meshNodes.length === 0) {
      console.log(`  ℹ️  No devices in mesh for tenant "${tenant.name}"`);
      return;
    }
    
    console.log(`  🏷️  Tagging ${meshNodes.length} device(s) for tenant "${tenant.name}"`);
    
    for (const node of meshNodes) {
      const parsed = api.constructor.parseNodeData(node);
      const tagData = api.constructor.parseDeviceTags(node.tags);
      
      // Only update if tenant tag is missing or different
      if (tagData.tenantId !== tenant.tenant_id) {
        console.log(`     └─ ${parsed.hostname} → tenant:${tenant.tenant_id}`);
        await api.updateDeviceMetadata(parsed.nodeId, {
          tenantId: tenant.tenant_id,
          customerId: tagData.customerId,
          tags: tagData.customTags
        });
      }
    }
  } catch (error) {
    console.error(`  ⚠️  Error tagging devices for tenant "${tenant.name}":`, error.message);
  }
}
 
/**
 * Run the startup sync
 */
async function runStartupSync() {
  console.log(`\n${'='.repeat(60)}`);
  console.log('🚀 TENANT-MESHCENTRAL STARTUP SYNC');
  console.log(`${'='.repeat(60)}\n`);
  
  try {
    // Wait for MeshCentral to be ready
    console.log(`⏳ Waiting ${STARTUP_DELAY}ms for MeshCentral to start...`);
    await new Promise(resolve => setTimeout(resolve, STARTUP_DELAY));
    
    // Get all tenants
    const tenantsResult = await db.query(
      'SELECT tenant_id, name, meshcentral_group_id, meshcentral_setup_complete FROM tenants ORDER BY created_at'
    );
    
    if (tenantsResult.rows.length === 0) {
      console.log('ℹ️  No tenants found, skipping sync\n');
      return;
    }
    
    console.log(`📊 Found ${tenantsResult.rows.length} tenants to sync\n`);
    
    // Connect to MeshCentral
    console.log(`🔌 Connecting to MeshCentral: ${MESHCENTRAL_URL}`);
    const api = new MeshCentralAPI({
      url: MESHCENTRAL_URL,
      username: MESHCENTRAL_USER,
      password: MESHCENTRAL_PASSWORD
    });
    
    await api.login();
    console.log(`✅ Connected to MeshCentral as ${MESHCENTRAL_USER}\n`);
    
    // Fetch all existing mesh groups
    console.log(`📦 Fetching existing mesh groups from MeshCentral...`);
    const existingMeshes = await api.getMeshes();
    console.log(`✅ Found ${existingMeshes.length} existing mesh group(s)\n`);
    
    // Process each tenant
    let created = 0;
    let existing = 0;
    let linked = 0;
    let failed = 0;
    
    for (const tenant of tenantsResult.rows) {
      console.log(`\n🔄 Processing tenant: ${tenant.name} (${tenant.tenant_id})`);
      try {
        const result = await ensureTenantMesh(api, tenant, existingMeshes);
        if (result.created) {
          created++;
        } else if (result.linked) {
          linked++;
        } else {
          existing++;
        }
      } catch (error) {
        failed++;
      }
    }
    
    console.log(`\n${'='.repeat(60)}`);
    console.log('✅ STARTUP SYNC COMPLETE');
    console.log(`${'='.repeat(60)}`);
    console.log(`📊 Results:`);
    console.log(`   - Created: ${created} new mesh group(s)`);
    console.log(`   - Linked: ${linked} existing mesh group(s)`);
    console.log(`   - Already synced: ${existing} mesh group(s)`);
    console.log(`   - Failed: ${failed} tenant(s)`);
    console.log(`${'='.repeat(60)}\n`);
    
  } catch (error) {
    console.error('\n❌ STARTUP SYNC FAILED:', error.message);
    console.error('Stack:', error.stack);
    console.log('\nℹ️  Note: This is non-fatal. You can manually trigger sync via:');
    console.log('   POST /api/tenant-meshcentral-sync/sync-all\n');
  }
}
 
/**
 * Initialize startup sync if enabled
 */
function initStartupSync() {
  const enabled = process.env.TENANT_SYNC_ON_STARTUP === 'true'; // Disabled by default (changed to prevent duplicates)
  
  if (!enabled) {
    console.log('ℹ️  Tenant-MeshCentral startup sync is disabled (set TENANT_SYNC_ON_STARTUP=true to enable)');
    return;
  }
  
  // Run in background (don't block server startup)
  setImmediate(() => {
    runStartupSync().catch(err => {
      console.error('❌ Startup sync error:', err);
    });
  });
}
 
module.exports = {
  runStartupSync,
  initStartupSync
};