spacesService.js

Go to the documentation of this file.

// Digital Ocean Spaces Service - S3-compatible object storage for installers
const AWS = require('aws-sdk');
const fs = require('fs');
const path = require('path');
 
// Configure DO Spaces (S3-compatible)
const spacesEndpoint = new AWS.Endpoint(process.env.DO_SPACES_ENDPOINT || 'nyc3.digitaloceanspaces.com');
const s3 = new AWS.S3({
  endpoint: spacesEndpoint,
  accessKeyId: process.env.DO_SPACES_KEY,
  secretAccessKey: process.env.DO_SPACES_SECRET,
  region: process.env.DO_SPACES_REGION || 'nyc3',
  signatureVersion: 'v4'
});
 
const BUCKET_NAME = process.env.DO_SPACES_BUCKET || 'rmm-installers';
 
/**
 * Upload a file to DO Spaces
 * @param {string} filePath - Local file path
 * @param {string} key - Object key in Spaces (path/filename)
 * @param {object} options - Additional options (ACL, metadata, etc.)
 * @returns {Promise<object>} Upload result
 */
async function uploadFile(filePath, key, options = {}) {
  if (!fs.existsSync(filePath)) {
    throw new Error(`File not found: ${filePath}`);
  }
 
  const fileContent = fs.readFileSync(filePath);
  const fileName = path.basename(filePath);
  const contentType = getContentType(fileName);
 
  const params = {
    Bucket: BUCKET_NAME,
    Key: key,
    Body: fileContent,
    ContentType: contentType,
    ACL: options.acl || 'private', // private by default, use signed URLs
    Metadata: options.metadata || {},
    CacheControl: options.cacheControl || 'public, max-age=86400', // 24 hours
    ...options
  };
 
  try {
    const result = await s3.putObject(params).promise();
    console.log(`[Spaces] Uploaded ${fileName} to ${key}`);
    return result;
  } catch (error) {
    console.error(`[Spaces] Upload failed for ${key}:`, error.message);
    throw error;
  }
}
 
/**
 * Generate a signed URL for secure download
 * @param {string} key - Object key in Spaces
 * @param {number} expiresIn - Expiration time in seconds (default: 1 hour)
 * @returns {string} Signed URL
 */
function getSignedUrl(key, expiresIn = 3600) {
  const params = {
    Bucket: BUCKET_NAME,
    Key: key,
    Expires: expiresIn
  };
 
  try {
    const url = s3.getSignedUrl('getObject', params);
    console.log(`[Spaces] Generated signed URL for ${key} (expires in ${expiresIn}s)`);
    return url;
  } catch (error) {
    console.error(`[Spaces] Failed to generate signed URL for ${key}:`, error.message);
    throw error;
  }
}
 
/**
 * Get a public URL (for public objects with CDN)
 * @param {string} key - Object key in Spaces
 * @returns {string} Public URL
 */
function getPublicUrl(key) {
  const endpoint = process.env.DO_SPACES_ENDPOINT || 'nyc3.digitaloceanspaces.com';
  const cdnEndpoint = process.env.DO_SPACES_CDN_ENDPOINT; // Optional CDN endpoint
  
  if (cdnEndpoint) {
    return `https://${cdnEndpoint}/${key}`;
  }
  
  return `https://${BUCKET_NAME}.${endpoint}/${key}`;
}
 
/**
 * Check if an object exists in Spaces
 * @param {string} key - Object key
 * @returns {Promise<boolean>}
 */
async function objectExists(key) {
  try {
    await s3.headObject({ Bucket: BUCKET_NAME, Key: key }).promise();
    return true;
  } catch (error) {
    if (error.code === 'NotFound') {
      return false;
    }
    throw error;
  }
}
 
/**
 * Delete an object from Spaces
 * @param {string} key - Object key
 * @returns {Promise<object>}
 */
async function deleteObject(key) {
  const params = {
    Bucket: BUCKET_NAME,
    Key: key
  };
 
  try {
    const result = await s3.deleteObject(params).promise();
    console.log(`[Spaces] Deleted ${key}`);
    return result;
  } catch (error) {
    console.error(`[Spaces] Failed to delete ${key}:`, error.message);
    throw error;
  }
}
 
/**
 * List objects in a prefix (folder)
 * @param {string} prefix - Prefix to filter objects
 * @param {number} maxKeys - Maximum number of keys to return
 * @returns {Promise<Array>}
 */
async function listObjects(prefix = '', maxKeys = 1000) {
  const params = {
    Bucket: BUCKET_NAME,
    Prefix: prefix,
    MaxKeys: maxKeys
  };
 
  try {
    const result = await s3.listObjectsV2(params).promise();
    return result.Contents || [];
  } catch (error) {
    console.error(`[Spaces] Failed to list objects with prefix ${prefix}:`, error.message);
    throw error;
  }
}
 
/**
 * Get object metadata
 * @param {string} key - Object key
 * @returns {Promise<object>}
 */
async function getMetadata(key) {
  try {
    const result = await s3.headObject({ Bucket: BUCKET_NAME, Key: key }).promise();
    return {
      size: result.ContentLength,
      lastModified: result.LastModified,
      contentType: result.ContentType,
      etag: result.ETag,
      metadata: result.Metadata
    };
  } catch (error) {
    console.error(`[Spaces] Failed to get metadata for ${key}:`, error.message);
    throw error;
  }
}
 
/**
 * Helper: Determine content type from filename
 * @param {string} filename
 * @returns {string}
 */
function getContentType(filename) {
  const ext = path.extname(filename).toLowerCase();
  const types = {
    '.exe': 'application/x-msdownload',
    '.msi': 'application/x-msi',
    '.zip': 'application/zip',
    '.tar': 'application/x-tar',
    '.gz': 'application/gzip',
    '.json': 'application/json',
    '.xml': 'application/xml',
    '.txt': 'text/plain'
  };
  return types[ext] || 'application/octet-stream';
}
 
/**
 * Upload installer and return signed URL
 * @param {string} filePath - Local installer file path
 * @param {string} tenantId - Tenant ID
 * @param {string} installerType - Type: 'bootstrapper', 'agent', 'tray', etc.
 * @returns {Promise<object>} { key, signedUrl, publicUrl }
 */
async function uploadInstaller(filePath, tenantId, installerType = 'agent') {
  const fileName = path.basename(filePath);
  const key = `installers/${tenantId}/${installerType}/${fileName}`;
  
  await uploadFile(filePath, key, {
    metadata: {
      tenantId: tenantId,
      installerType: installerType,
      uploadedAt: new Date().toISOString()
    },
    cacheControl: 'public, max-age=3600' // 1 hour cache
  });
 
  const signedUrl = getSignedUrl(key, 3600); // 1 hour expiry
  const publicUrl = getPublicUrl(key);
 
  return {
    key,
    signedUrl,
    publicUrl,
    fileName
  };
}
 
/**
 * Clean up old installers for a tenant
 * @param {string} tenantId
 * @param {number} keepRecent - Number of recent installers to keep
 */
async function cleanupOldInstallers(tenantId, keepRecent = 5) {
  const prefix = `installers/${tenantId}/`;
  const objects = await listObjects(prefix);
  
  if (objects.length <= keepRecent) {
    console.log(`[Spaces] No cleanup needed for tenant ${tenantId} (${objects.length} installers)`);
    return;
  }
 
  // Sort by last modified, keep most recent
  objects.sort((a, b) => b.LastModified - a.LastModified);
  const toDelete = objects.slice(keepRecent);
 
  console.log(`[Spaces] Cleaning up ${toDelete.length} old installers for tenant ${tenantId}`);
  
  for (const obj of toDelete) {
    await deleteObject(obj.Key);
  }
}
 
module.exports = {
  uploadFile,
  getSignedUrl,
  getPublicUrl,
  objectExists,
  deleteObject,
  listObjects,
  getMetadata,
  uploadInstaller,
  cleanupOldInstallers
};