@oussema_mili/test-pkg-123 1.1.32

package/docker-actions/volumes.js

@@ -0,0 +1,713 @@
+import { docker } from './containers.js';
+import { formatCreatedTime } from '../helper-functions.js';
+import { exec } from 'child_process';
+import util from 'util';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadConfig } from '../store/configStore.js';
+import { getDaemonState } from '../store/daemonStore.js';
+
+const execPromise = util.promisify(exec);
+const fsPromises = fs.promises;
+
+// Get the backup directory in the user's home directory
+function getBackupDir() {
+  return path.join(os.homedir(), 'volume-backups');
+}
+
+// Get the agent's HTTP port (from daemon state or config)
+function getAgentPort() {
+  const state = getDaemonState();
+  if (state?.port) {
+    return state.port;
+  }
+  const config = loadConfig();
+  return config.wsPort || 3001;
+}
+
+// Cache for docker system df result to avoid concurrent operations
+let dfCache = null;
+let dfCacheTime = 0;
+const CACHE_TTL = 5000; // 5 seconds cache
+
+async function handleVolumeAction(ws, action, payload) {
+  switch (action) {
+    case 'fetchVolumes':
+      return await handleFetchVolumes(ws, payload);
+    case 'createVolume':
+      return await handleCreateVolume(ws, payload);
+    case 'deleteVolume':
+      return await handleDeleteVolume(ws, payload);
+    case 'inspectVolume':
+      return await handleInspectVolume(ws, payload);
+    case 'getContainersUsingVolume':
+      return await handleGetContainersUsingVolume(ws, payload);
+    case 'backupVolume':
+      return await handleBackupVolume(ws, payload);
+    case 'listVolumeBackups':
+      return await handleListVolumeBackups(ws, payload);
+    case 'restoreVolumeFromBackup':
+      return await handleRestoreVolumeFromBackup(ws, payload);
+    case 'deleteVolumeBackup':
+      return await handleDeleteVolumeBackup(ws, payload);
+    case 'getBackupDownloadUrl':
+      return await handleGetBackupDownloadUrl(ws, payload);
+    default:
+      throw new Error(`Unknown volume action: ${action}`);
+  }
+}
+
+// Get containers using a volume
+async function getContainersUsingVolume(volumeName) {
+  try {
+    const containers = await docker.listContainers({ all: true });
+    const usedBy = [];
+
+    for (const container of containers) {
+      const containerInfo = await docker.getContainer(container.Id).inspect();
+
+      if (containerInfo.Mounts) {
+        for (const mount of containerInfo.Mounts) {
+          if (
+            mount.Name === volumeName ||
+            (mount.Source && mount.Source.endsWith(`/${volumeName}/_data`))
+          ) {
+            usedBy.push(containerInfo.Name.replace(/^\//, ''));
+            break;
+          }
+        }
+      }
+    }
+
+    return usedBy;
+  } catch (error) {
+    console.error('Error getting containers using volume:', error);
+    return [];
+  }
+}
+
+// Get all volumes sizes (cached to avoid concurrent docker system df operations)
+async function getAllVolumesSizes() {
+  try {
+    // Check cache
+    const now = Date.now();
+    if (dfCache && (now - dfCacheTime) < CACHE_TTL) {
+      return dfCache;
+    }
+
+    // Run `docker system df -v` only once
+    const { stdout } = await execPromise('docker system df -v');
+
+    // Split into lines
+    const lines = stdout.split('\n');
+
+    // Parse sizes for all volumes
+    const sizes = {};
+    for (const line of lines) {
+      // Skip header and empty lines
+      if (!line.trim() || line.includes('VOLUME NAME')) continue;
+
+      // Normalize whitespace and split
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const volumeName = parts[0];
+        const size = parts[2];
+        sizes[volumeName] = size;
+      }
+    }
+
+    // Update cache
+    dfCache = sizes;
+    dfCacheTime = now;
+
+    return sizes;
+  } catch (error) {
+    console.error('Error fetching volume sizes:', error.message);
+    return {};
+  }
+}
+
+// Get volume size for a specific volume
+async function getVolumeSize(volumeName, allSizes = null) {
+  try {
+    // If we already have all sizes, use them
+    if (allSizes && allSizes[volumeName]) {
+      return allSizes[volumeName];
+    }
+
+    // Otherwise get all sizes (this will use cache if available)
+    const sizes = await getAllVolumesSizes();
+    return sizes[volumeName] || 'N/A';
+  } catch (error) {
+    console.error('Error fetching volume size:', error.message);
+    return 'N/A';
+  }
+}
+
+async function handleFetchVolumes(ws, payload = {}) {
+  try {
+    const { Volumes } = await docker.listVolumes();
+
+    // Get all volume sizes ONCE to avoid concurrent docker system df operations
+    const allSizes = await getAllVolumesSizes();
+
+    const volumePromises = Volumes.map(async (volume) => {
+      const usedBy = await getContainersUsingVolume(volume.Name);
+      const size = allSizes[volume.Name] || 'N/A';
+
+      return {
+        id: volume.Name,
+        name: volume.Name,
+        driver: volume.Driver,
+        mountpoint: volume.Mountpoint,
+        created: formatCreatedTime(
+          new Date(volume.CreatedAt || Date.now()).getTime() / 1000
+        ),
+        size,
+        used: usedBy.length > 0,
+        usedBy,
+      };
+    });
+
+    const formattedVolumes = await Promise.all(volumePromises);
+
+    // Sort volumes alphabetically by name for consistent ordering
+    formattedVolumes.sort((a, b) => a.name.localeCompare(b.name));
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumes',
+        volumes: formattedVolumes,
+        requestId: payload.requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error fetching volumes:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to fetch volumes: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleCreateVolume(ws, payload) {
+  try {
+    const { name, driver, requestId } = payload;
+
+    const volume = await docker.createVolume({
+      Name: name,
+      Driver: driver,
+    });
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumeCreated',
+        volume: {
+          id: volume.Name,
+          name: volume.Name,
+          driver: volume.Driver,
+          mountpoint: volume.Mountpoint,
+          created: 'Just now',
+          size: '0 B',
+          used: false,
+          usedBy: [],
+        },
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error creating volume:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to create volume: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleDeleteVolume(ws, payload) {
+  try {
+    const { id, requestId } = payload;
+
+    // Check if volume is in use
+    const usedBy = await getContainersUsingVolume(id);
+    if (usedBy.length > 0) {
+      ws.send(
+        JSON.stringify({
+          type: 'error',
+          error: `Volume is in use by containers: ${usedBy.join(', ')}`,
+          requestId,
+        })
+      );
+      return;
+    }
+
+    // Delete the volume
+    const volume = docker.getVolume(id);
+    await volume.remove();
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumeDeleted',
+        id,
+        success: true,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error deleting volume:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to delete volume: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleInspectVolume(ws, payload) {
+  try {
+    const { name, requestId } = payload;
+    const volume = docker.getVolume(name);
+    const inspectionData = await volume.inspect();
+
+    // Get the volume size and containers using it
+    const [size, usedBy] = await Promise.all([
+      getVolumeSize(name),
+      getContainersUsingVolume(name),
+    ]);
+
+    // Add the additional computed fields to the inspection data
+    const fullInspectionData = {
+      ...inspectionData,
+      size,
+      used: usedBy.length > 0,
+      usedBy,
+      // Also include size in UsageData format
+      UsageData: {
+        Size: size,
+        RefCount: usedBy.length,
+      },
+    };
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumeInspected',
+        data: fullInspectionData,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error inspecting volume:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to inspect volume: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleGetContainersUsingVolume(ws, payload) {
+  try {
+    const { name, requestId } = payload;
+
+    const containers = await getContainersUsingVolume(name);
+
+    ws.send(
+      JSON.stringify({
+        type: 'containersUsingVolume',
+        containers,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error getting containers using volume:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: 'Failed to get containers using volume: ' + error.message,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleBackupVolume(ws, payload = {}) {
+  try {
+    const { volumeName, requestId } = payload;
+
+    if (!volumeName) {
+      throw new Error('Missing volume name.');
+    }
+
+    // Create backup directory in user's home directory
+    const backupDir = getBackupDir();
+
+    try {
+      await fsPromises.mkdir(backupDir, { recursive: true });
+    } catch (mkdirError) {
+      console.log('Backup directory already exists or created');
+    }
+
+    // Check if alpine image exists first, pull if needed
+    try {
+      await docker.getImage('alpine:latest').inspect();
+      console.log('Alpine image found, proceeding with backup');
+    } catch (inspectError) {
+      // Pull the image and wait for it to complete
+      await new Promise((resolve, reject) => {
+        docker.pull('alpine:latest', (err, stream) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          docker.modem.followProgress(stream, (err, res) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(res);
+            }
+          });
+        });
+      });
+
+      // Additional wait to ensure image is fully available
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupFileName = `${volumeName}-backup-${timestamp}.tar`;
+    const backupFilePath = path.join(backupDir, backupFileName);
+
+    // Create a temporary container to access the volume and create backup
+    const container = await docker.createContainer({
+      Image: 'alpine:latest',
+      Cmd: ['tar', 'cf', `/backup/${backupFileName}`, '-C', '/data', '.'],
+      HostConfig: {
+        Binds: [
+          `${volumeName}:/data:ro`, // Mount volume as read-only
+          `${backupDir}:/backup`, // Mount backup directory
+        ],
+      },
+      WorkingDir: '/data',
+    });
+
+    await container.start();
+    const result = await container.wait();
+    await container.remove();
+
+    // Check if backup was created successfully
+    if (result.StatusCode !== 0) {
+      throw new Error(
+        `Backup process failed with status code: ${result.StatusCode}`
+      );
+    }
+
+    // Verify the backup file exists
+    try {
+      const stats = await fsPromises.stat(backupFilePath);
+      console.log(
+        `✅ Backup created successfully: ${backupFilePath} (${formatFileSize(
+          stats.size
+        )})`
+      );
+    } catch (statError) {
+      throw new Error('Backup file was not created successfully');
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'backupVolume',
+        message: `Backup of volume "${volumeName}" completed successfully.`,
+        backupPath: backupFilePath,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error backing up volume:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: `Failed to backup volume: ${error.message}`,
+        requestId: payload?.requestId,
+      })
+    );
+  }
+}
+
+async function handleListVolumeBackups(ws, payload = {}) {
+  try {
+    const { requestId } = payload;
+
+    // Use the same backup directory as backup creation
+    const backupDir = getBackupDir();
+    const backups = [];
+
+    try {
+      // Ensure backup directory exists
+      await fsPromises.mkdir(backupDir, { recursive: true });
+
+      const files = await fsPromises.readdir(backupDir);
+      const backupFiles = files.filter(
+        (file) => file.includes('-backup-') && file.endsWith('.tar')
+      );
+
+      for (const file of backupFiles) {
+        const filePath = path.join(backupDir, file);
+        const stats = await fsPromises.stat(filePath);
+
+        // Extract volume name from filename (format: volumeName-backup-timestamp.tar)
+        const volumeName = file.split('-backup-')[0];
+
+        backups.push({
+          id: `backup-${file}`,
+          volumeName: volumeName,
+          path: filePath,
+          size: formatFileSize(stats.size),
+          created: Math.floor(stats.mtime.getTime() / 1000),
+        });
+      }
+
+      // Sort backups by creation time (newest first)
+      backups.sort(
+        (a, b) => new Date(b.created).getTime() - new Date(a.created).getTime()
+      );
+    } catch (dirError) {
+      console.log('No backup directory or files found:', dirError.message);
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumeBackups',
+        backups,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error listing volume backups:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: `Failed to list volume backups: ${error.message}`,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+// Helper function to format file sizes
+function formatFileSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+async function handleRestoreVolumeFromBackup(ws, payload = {}) {
+  try {
+    const { backupPath, volumeName, requestId } = payload;
+
+    if (!backupPath || !volumeName) {
+      throw new Error('Missing backup path or volume name');
+    }
+
+
+    // Verify backup file exists
+    try {
+      await fsPromises.access(backupPath);
+    } catch (accessError) {
+      throw new Error('Backup file not found');
+    }
+
+    // Get backup directory and filename
+    const backupDir = path.dirname(backupPath);
+    const backupFileName = path.basename(backupPath);
+
+    console.log(
+      `Restoring volume "${volumeName}" from backup: ${backupFileName}`
+    );
+
+    // Check if alpine image exists first, pull if needed
+    try {
+      await docker.getImage('alpine:latest').inspect();
+      console.log('Alpine image found, proceeding with restore');
+    } catch (inspectError) {
+      // Pull the image and wait for it to complete
+      await new Promise((resolve, reject) => {
+        docker.pull('alpine:latest', (err, stream) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          docker.modem.followProgress(stream, (err, res) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(res);
+            }
+          });
+        });
+      });
+
+      // Additional wait to ensure image is fully available
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+
+    // Create a temporary container to restore the volume
+    const container = await docker.createContainer({
+      Image: 'alpine:latest',
+      Cmd: ['sh', '-c', `cd /data && tar xf /backup/${backupFileName}`],
+      HostConfig: {
+        Binds: [
+          `${volumeName}:/data`, // Mount target volume
+          `${backupDir}:/backup:ro`, // Mount backup directory as read-only
+        ],
+      },
+      WorkingDir: '/data',
+    });
+
+    await container.start();
+    const result = await container.wait();
+    await container.remove();
+
+    // Check if restore was successful
+    if (result.StatusCode !== 0) {
+      throw new Error(
+        `Restore process failed with status code: ${result.StatusCode}`
+      );
+    }
+
+    ws.send(
+      JSON.stringify({
+        type: 'volumeRestored',
+        message: `Volume "${volumeName}" restored successfully from backup`,
+        volumeName,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error restoring volume from backup:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: `Failed to restore volume from backup: ${error.message}`,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleDeleteVolumeBackup(ws, payload = {}) {
+  try {
+    const { backupPath, requestId } = payload;
+
+    if (!backupPath) {
+      throw new Error('Missing backup path');
+    }
+
+    // Security check: only allow deletion from the backup directory
+    const backupDir = getBackupDir();
+    const normalizedBackupPath = path.resolve(backupPath);
+    const normalizedBackupDir = path.resolve(backupDir);
+
+    if (
+      !normalizedBackupPath.startsWith(normalizedBackupDir) ||
+      !path.basename(backupPath).includes('-backup-') ||
+      !backupPath.endsWith('.tar')
+    ) {
+      throw new Error('Invalid backup path');
+    }
+
+    // Delete the actual backup file
+    await fsPromises.unlink(backupPath);
+
+    ws.send(
+      JSON.stringify({
+        type: 'backupDeleted',
+        message: `Backup at "${path.basename(
+          backupPath
+        )}" deleted successfully`,
+        success: true,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error deleting volume backup:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: `Failed to delete volume backup: ${error.message}`,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+async function handleGetBackupDownloadUrl(ws, payload = {}) {
+  try {
+    const { backupPath, requestId } = payload;
+
+    if (!backupPath) {
+      throw new Error('Missing backup path');
+    }
+
+    // Get backup directory from home directory
+    const backupDir = getBackupDir();
+    const normalizedBackupPath = path.resolve(backupPath);
+    const normalizedBackupDir = path.resolve(backupDir);
+
+    if (
+      !normalizedBackupPath.startsWith(normalizedBackupDir) ||
+      !path.basename(backupPath).includes('-backup-') ||
+      !backupPath.endsWith('.tar')
+    ) {
+      throw new Error('Invalid backup path');
+    }
+
+    // Check if file exists before providing download URL
+    try {
+      await fsPromises.access(backupPath);
+    } catch (accessError) {
+      throw new Error('Backup file not found');
+    }
+
+    // Return the download URL pointing to the agent's HTTP server
+    const agentPort = getAgentPort();
+    const downloadUrl = `http://localhost:${agentPort}/api/download?path=${encodeURIComponent(backupPath)}`;
+
+    ws.send(
+      JSON.stringify({
+        type: 'backupDownloadUrl',
+        downloadUrl,
+        requestId,
+      })
+    );
+  } catch (error) {
+    console.error('Error getting backup download URL:', error);
+    ws.send(
+      JSON.stringify({
+        type: 'error',
+        error: `Failed to get backup download URL: ${error.message}`,
+        requestId: payload.requestId,
+      })
+    );
+  }
+}
+
+export default { handleVolumeAction };
+
+export {
+  handleVolumeAction,
+};