@git.zone/cli 3.2.0 → 4.0.0

package/ts/mod_services/classes.servicenames.ts

@@ -0,0 +1,76 @@
+import {
+  CLI_NAMESPACE,
+  getCliConfigValueFromData,
+  getCliNamespaceConfig,
+  readSmartconfigFile,
+} from '../helpers.smartconfig.js';
+import type { TServiceName } from './classes.servicedatamarker.js';
+
+export const allowedServiceNames: TServiceName[] = [
+  'mongodb',
+  'objectstorage',
+  'elasticsearch',
+];
+
+/** Normalize interactive/CLI input. The legacy provider name is deliberately absent. */
+export const normalizeUserServiceName = (serviceArg: string): string => {
+  switch (serviceArg) {
+    case 'mongo':
+    case 'mongodb':
+      return 'mongodb';
+    case 'objectstorage':
+    case 's3':
+      return 'objectstorage';
+    case 'elastic':
+    case 'elasticsearch':
+    case 'es':
+      return 'elasticsearch';
+    default:
+      return serviceArg;
+  }
+};
+
+export const normalizeUserServiceNames = (servicesArg: readonly string[]): string[] => {
+  return Array.from(
+    new Set(
+      servicesArg
+        .map((serviceArg) => normalizeUserServiceName(serviceArg.trim()))
+        .filter(Boolean),
+    ),
+  );
+};
+
+export const assertSupportedCliSchema = (cliConfigArg: Record<string, any>): void => {
+  if (
+    cliConfigArg.schemaVersion !== undefined &&
+    (!Number.isInteger(cliConfigArg.schemaVersion) ||
+      cliConfigArg.schemaVersion < 1 ||
+      cliConfigArg.schemaVersion > 2)
+  ) {
+    throw new Error(`${CLI_NAMESPACE} uses an unsupported schema version.`);
+  }
+};
+
+/** Read only canonical persisted service names after the startup migration ran. */
+export const readPersistedServiceConfiguration = async (
+  cwdArg: string = process.cwd(),
+): Promise<string[]> => {
+  const smartconfigData = await readSmartconfigFile(cwdArg);
+  assertSupportedCliSchema(getCliNamespaceConfig(smartconfigData));
+  const rawServices = getCliConfigValueFromData(smartconfigData, 'services');
+  if (rawServices === undefined) {
+    return [];
+  }
+  if (!Array.isArray(rawServices) || !rawServices.every((service) => typeof service === 'string')) {
+    throw new Error('Persisted services configuration must be an array of service names.');
+  }
+  if (
+    rawServices.some(
+      (service) => !allowedServiceNames.some((allowedService) => allowedService === service),
+    ) ||
+    new Set(rawServices).size !== rawServices.length
+  ) {
+    throw new Error('Persisted services configuration is not canonical.');
+  }
+  return [...rawServices];
+};

package/ts/mod_services/classes.servicepruner.ts

@@ -3,15 +3,21 @@ import * as helpers from './helpers.js';
 import { DockerContainer, type IContainerInspectInfo } from './classes.dockercontainer.js';
 import { GlobalRegistry, type IRegisteredProject } from './classes.globalregistry.js';
 import {
+  getServiceContainerLabels,
   getServiceDataDirectory,
+  hasExactServiceContainerLabels,
   isSafeServiceDataPath,
-  isServiceOwnedByLabels,
+  isLegacyMinioContainerLabels,
+  isServiceOperationHelperLabels,
+  markerProvesServiceDataDirectory,
   readServiceDataMarker,
+  recordServiceDataDirectory,
   serviceImages,
   serviceNames,
   serviceToolLabel,
   type TServiceName,
 } from './classes.servicedatamarker.js';
+import { withServiceDataOperationLock } from './classes.interprocesslock.js';
 import { logger } from '../gitzone.logging.js';
 
 /** Default inactivity threshold before a project is even considered stale. */
@@ -72,7 +78,12 @@ export interface IServicePrunePlan {
   dockerAvailable: boolean;
   projects: IServiceProjectReport[];
   registryEntriesToRemove: string[];
-  containersToRemove: Array<{ id: string; name: string; projectPath: string }>;
+  containersToRemove: Array<{
+    id: string;
+    name: string;
+    projectPath: string;
+    service: TServiceName;
+  }>;
   dataDirsToRemove: Array<{ projectPath: string; service: TServiceName; path: string; sizeBytes: number }>;
   skipped: IServiceSkipReason[];
   totals: {
@@ -97,6 +108,44 @@ interface IProjectCandidate {
 
 const dayInMs = 24 * 60 * 60 * 1000;
 
+const hasGitZoneLabels = (labelsArg: Record<string, string>): boolean => {
+  return Object.keys(labelsArg).some((keyArg) => keyArg.startsWith('git.zone.'));
+};
+
+const getRegisteredServiceForContainer = (
+  projectArg: IRegisteredProject | undefined,
+  containerNameArg: string,
+): TServiceName | undefined => {
+  if (!projectArg) {
+    return undefined;
+  }
+  const matches: TServiceName[] = [];
+  if (projectArg.containers.mongo === containerNameArg) matches.push('mongodb');
+  if (projectArg.containers.objectstorage === containerNameArg) matches.push('objectstorage');
+  if (projectArg.containers.elasticsearch === containerNameArg) matches.push('elasticsearch');
+  return matches.length === 1 ? matches[0] : undefined;
+};
+
+const hasCanonicalServiceLabels = (
+  containerArg: IContainerInspectInfo,
+  projectPathArg: string,
+): boolean => {
+  const service = serviceNames.find(
+    (serviceArg) => containerArg.labels['git.zone.service'] === serviceArg,
+  );
+  if (!service) {
+    return false;
+  }
+  return hasExactServiceContainerLabels(
+    containerArg.labels,
+    getServiceContainerLabels({
+      projectPath: projectPathArg,
+      service,
+      dataPath: getServiceDataDirectory(projectPathArg, service),
+    }),
+  );
+};
+
 /**
  * Plans and applies reclamation of resources created by `gitzone services`.
  *
@@ -145,6 +194,7 @@ export class ServicePruner {
     // versions). Their names are only trusted when exactly one registry entry
     // claims them.
     const nameClaims = new Map<string, string[]>();
+    const legacyNameClaims = new Map<string, string[]>();
     for (const [projectPath, project] of Object.entries(registryProjects)) {
       for (const containerName of Object.values(project.containers)) {
         if (!containerName) {
@@ -154,10 +204,15 @@ export class ServicePruner {
         claims.push(projectPath);
         nameClaims.set(containerName, claims);
       }
+      if (project.legacy?.minioContainer) {
+        const claims = legacyNameClaims.get(project.legacy.minioContainer) || [];
+        claims.push(projectPath);
+        legacyNameClaims.set(project.legacy.minioContainer, claims);
+      }
     }
 
     let legacyContainers: IContainerInspectInfo[] = [];
-    if (dockerAvailable && nameClaims.size > 0) {
+    if (dockerAvailable && (nameClaims.size > 0 || legacyNameClaims.size > 0)) {
       try {
         // One `docker ps -a` for all claimed names rather than one per name:
         // each shell-out is a spawned child process, and this runs on every
@@ -167,7 +222,9 @@ export class ServicePruner {
         const allIds = await this.docker.listIds([]);
         const candidateIds = allIds.filter((id) => !labeledIds.has(id));
         const inspected = await this.docker.inspectMany(candidateIds);
-        legacyContainers = inspected.filter((container) => nameClaims.has(container.name));
+        legacyContainers = inspected.filter(
+          (container) => nameClaims.has(container.name) || legacyNameClaims.has(container.name),
+        );
       } catch (error) {
         dockerAvailable = false;
         const message = error instanceof Error ? error.message : String(error);
@@ -220,7 +277,10 @@ export class ServicePruner {
     const ambiguousProjectPaths = new Set<string>();
 
     for (const container of legacyContainers) {
-      const claims = nameClaims.get(container.name) || [];
+      const claims = [
+        ...(nameClaims.get(container.name) || []),
+        ...(legacyNameClaims.get(container.name) || []),
+      ];
       if (claims.length !== 1) {
         skipped.push({
           target: container.name,
@@ -240,7 +300,12 @@ export class ServicePruner {
     // Classify and decide.
     const projects: IServiceProjectReport[] = [];
     const registryEntriesToRemove: string[] = [];
-    const containersToRemove: Array<{ id: string; name: string; projectPath: string }> = [];
+    const containersToRemove: Array<{
+      id: string;
+      name: string;
+      projectPath: string;
+      service: TServiceName;
+    }> = [];
     const dataDirsToRemove: Array<{
       projectPath: string;
       service: TServiceName;
@@ -278,14 +343,36 @@ export class ServicePruner {
         stateReason = `active ${inactiveDays} day(s) ago`;
       }
 
-      const anyContainerRunning = candidate.containers.some((container) => container.running);
-
       // Containers
       const containerReports: IServiceContainerReport[] = [];
       for (const container of candidate.containers) {
         let reclaimable = false;
         let reason: string;
-        if (!dockerAvailable) {
+        const labelOwned = hasCanonicalServiceLabels(container, candidate.projectPath);
+        const registryClaims = nameClaims.get(container.name) || [];
+        const registeredService = getRegisteredServiceForContainer(
+          candidate.registryEntry,
+          container.name,
+        );
+        const registryOwned =
+          !hasGitZoneLabels(container.labels) &&
+          registeredService !== undefined &&
+          registeredService !== 'objectstorage' &&
+          registryClaims.length === 1 &&
+          plugins.path.resolve(registryClaims[0]) === candidate.projectPath;
+        const legacyContainer =
+          isLegacyMinioContainerLabels(container.labels) ||
+          legacyNameClaims.has(container.name);
+        const operationHelper = isServiceOperationHelperLabels(container.labels);
+        if (legacyContainer) {
+          reason = 'legacy MinIO migration resource; preserved and never pruned';
+        } else if (operationHelper) {
+          reason = 'transient service operation helper; owned only by its invocation';
+        } else if (!labelOwned && !registryOwned) {
+          reason = hasGitZoneLabels(container.labels)
+            ? 'GitZone ownership labels are incomplete or noncanonical'
+            : 'container has no unambiguous registry ownership claim';
+        } else if (!dockerAvailable) {
           reason = 'docker unavailable';
         } else if (state === 'live') {
           reason = 'project is live';
@@ -306,24 +393,52 @@ export class ServicePruner {
           reason,
         });
         if (reclaimable) {
+          const service =
+            serviceNames.find(
+              (serviceArg) => container.labels['git.zone.service'] === serviceArg,
+            ) || registeredService;
+          if (!service) {
+            throw new Error(`Could not identify service for container ${container.name}.`);
+          }
           containersToRemove.push({
             id: container.id,
             name: container.name,
             projectPath: candidate.projectPath,
+            service,
           });
         }
       }
-
       // Data directories
-      const ownershipProven = !!marker || !!candidate.registryEntry;
       const dataReports: IServiceDataDirReport[] = [];
       let totalDataBytes = 0;
       let reclaimableDataBytes = 0;
 
       for (const service of serviceNames) {
         const dataPath = getServiceDataDirectory(candidate.projectPath, service);
-        const exists = await plugins.smartfs.directory(dataPath).exists();
-        const sizeBytes = exists ? await helpers.getDirectorySize(dataPath) : 0;
+        const pendingDeletionPath = await this.docker.getPendingDataDeletionPath(
+          candidate.projectPath,
+          service,
+        );
+        const preservedContainer = containerReports.find(
+          (containerArg, indexArg) =>
+            !containerArg.reclaimable &&
+            (!pendingDeletionPath ||
+              !isServiceOperationHelperLabels(candidate.containers[indexArg].labels)),
+        );
+        const ownershipProven =
+          service === 'objectstorage'
+            ? markerProvesServiceDataDirectory(marker, candidate.projectPath, service) ||
+              candidate.containers.some(
+                (containerArg) =>
+                  containerArg.labels['git.zone.service'] === 'objectstorage' &&
+                  hasCanonicalServiceLabels(containerArg, candidate.projectPath),
+              )
+            : !!marker || !!candidate.registryEntry;
+        const canonicalExists = await plugins.smartfs.directory(dataPath).exists();
+        const exists = canonicalExists || !!pendingDeletionPath;
+        const sizeBytes = exists
+          ? await helpers.getDirectorySize(canonicalExists ? dataPath : pendingDeletionPath!)
+          : 0;
         totalDataBytes += sizeBytes;
 
         let reclaimable = false;
@@ -350,9 +465,8 @@ export class ServicePruner {
         } else if (mountConflict) {
           reason = `mounted by a running container (${mountConflict})`;
           blockedByRunningBytes += sizeBytes;
-        } else if (anyContainerRunning) {
-          reason = 'a container for this project is still running';
-          blockedByRunningBytes += sizeBytes;
+        } else if (preservedContainer) {
+          reason = `container ${preservedContainer.name} is preserved or still active`;
         } else {
           reclaimable = true;
           reason = `project stale, no container running, ownership proven by ${marker ? 'marker' : 'registry'}`;
@@ -376,12 +490,19 @@ export class ServicePruner {
       // exists would make it invisible to prune, `stop -g` and `cleanup -g`,
       // leaving it running forever under `restart: unless-stopped`.
       if (state === 'orphaned' && candidate.registryEntry) {
-        if (candidate.containers.length === 0) {
+        if (candidate.registryEntry.legacy?.minioContainer) {
+          skipped.push({
+            target: candidate.projectPath,
+            reason: `preserving legacy MinIO registry reference: ${candidate.registryEntry.legacy.minioContainer}`,
+          });
+        } else if (dockerAvailable && candidate.containers.length === 0) {
           registryEntriesToRemove.push(candidate.projectPath);
         } else {
           skipped.push({
             target: candidate.projectPath,
-            reason: `project directory is gone but ${candidate.containers.length} container(s) remain; keeping the registry entry so they stay identifiable`,
+            reason: dockerAvailable
+              ? `project directory is gone but ${candidate.containers.length} container(s) remain; keeping the registry entry so they stay identifiable`
+              : 'project directory is gone but Docker is unavailable; keeping the registry entry so containers remain identifiable',
           });
         }
       }
@@ -430,32 +551,71 @@ export class ServicePruner {
    * removing something that may since have become live.
    */
   public async applyPlan(planArg: IServicePrunePlan): Promise<void> {
-    if (!planArg.dockerAvailable && (planArg.containersToRemove.length > 0 || planArg.dataDirsToRemove.length > 0)) {
-      throw new Error('Refusing to apply container or data removal without a reachable Docker daemon');
+    if (
+      !planArg.dockerAvailable &&
+      (planArg.containersToRemove.length > 0 ||
+        planArg.dataDirsToRemove.length > 0 ||
+        planArg.registryEntriesToRemove.length > 0)
+    ) {
+      throw new Error('Refusing to apply service pruning without a reachable Docker daemon');
     }
 
     // Containers first, so their mounts stop protecting the data we then remove.
     if (planArg.containersToRemove.length > 0) {
-      const current = await this.docker.inspectMany(
-        planArg.containersToRemove.map((container) => container.id),
-      );
       for (const planned of planArg.containersToRemove) {
-        const container = current.find((candidate) => candidate.id === planned.id);
-        if (!container) {
-          throw new Error(`Refusing to remove vanished container: ${planned.name}`);
-        }
-        if (container.running) {
-          throw new Error(`Refusing to remove running container: ${container.name}`);
-        }
-        const labelOwned = isServiceOwnedByLabels(container.labels);
-        const registryOwned = await this.isClaimedByExactlyOneProject(container.name, planned.projectPath);
-        if (!labelOwned && !registryOwned) {
-          throw new Error(`Refusing to remove container with unproven ownership: ${container.name}`);
-        }
-        if (!(await this.docker.remove(container.name, false))) {
-          throw new Error(`Failed to remove container: ${container.name}`);
-        }
-        logger.log('ok', `Removed container ${container.name}`);
+        await withServiceDataOperationLock(planned.projectPath, planned.service, async () => {
+          const [container] = await this.docker.inspectMany([planned.id]);
+          if (!container || container.id !== planned.id || container.name !== planned.name) {
+            throw new Error(`Refusing to remove vanished or changed container: ${planned.name}`);
+          }
+          if (container.running) {
+            throw new Error(`Refusing to remove running container: ${container.name}`);
+          }
+          if (await plugins.smartfs.directory(planned.projectPath).exists()) {
+            const currentEntry = Object.entries(await this.globalRegistry.getAllProjects()).find(
+              ([projectPathArg]) =>
+                plugins.path.resolve(projectPathArg) === planned.projectPath,
+            )?.[1];
+            if (!currentEntry) {
+              throw new Error(
+                `Refusing container for a project without current activity evidence: ${container.name}`,
+              );
+            }
+            const inactiveDays = Math.floor(
+              (Date.now() - currentEntry.lastActive) / dayInMs,
+            );
+            if (inactiveDays <= this.staleDays) {
+              throw new Error(
+                `Refusing container for a project that became active: ${container.name} (${inactiveDays}d)`,
+              );
+            }
+          }
+          const labelOwned = hasCanonicalServiceLabels(container, planned.projectPath);
+          const registryOwned =
+            !hasGitZoneLabels(container.labels) &&
+            (await this.isClaimedByExactlyOneProject(container.name, planned.projectPath));
+          if (
+            isLegacyMinioContainerLabels(container.labels) ||
+            isServiceOperationHelperLabels(container.labels) ||
+            (await this.isLegacyContainerReference(container.name))
+          ) {
+            throw new Error(`Refusing to remove preserved service container: ${container.name}`);
+          }
+          if (!labelOwned && !registryOwned) {
+            throw new Error(`Refusing to remove container with unproven ownership: ${container.name}`);
+          }
+          if (
+            labelOwned &&
+            container.labels['git.zone.service'] === 'objectstorage' &&
+            (await plugins.smartfs
+              .directory(getServiceDataDirectory(planned.projectPath, 'objectstorage'))
+              .exists())
+          ) {
+            await recordServiceDataDirectory(planned.projectPath, 'objectstorage');
+          }
+          await this.docker.execArgv(['rm', container.id], { timeoutMs: 60_000 });
+          logger.log('ok', `Removed container ${container.name}`);
+        });
       }
     }
 
@@ -470,7 +630,15 @@ export class ServicePruner {
         }
         const marker = await readServiceDataMarker(planned.projectPath);
         const registered = await this.globalRegistry.isRegistered(planned.projectPath);
-        if (!marker && !registered) {
+        const ownershipProven =
+          planned.service === 'objectstorage'
+            ? markerProvesServiceDataDirectory(
+                marker,
+                planned.projectPath,
+                planned.service,
+              )
+            : !!marker || registered;
+        if (!ownershipProven) {
           throw new Error(`Refusing data path with unproven ownership: ${planned.path}`);
         }
         // Re-verify staleness: the project may have been started between
@@ -496,23 +664,87 @@ export class ServicePruner {
         if (conflict) {
           throw new Error(`Refusing mounted data path: ${planned.path} is used by ${conflict}`);
         }
-        if (!(await plugins.smartfs.directory(planned.path).exists())) {
+        const pendingDeletionPath = await this.docker.getPendingDataDeletionPath(
+          planned.projectPath,
+          planned.service,
+        );
+        if (
+          !(await plugins.smartfs.directory(planned.path).exists()) &&
+          !pendingDeletionPath
+        ) {
           continue;
         }
-        // Escalates to a privileged one-off container when the contents belong to
+        // Escalates to a root one-off container when the contents belong to
         // the container user; throws rather than deleting only part of the tree.
-        await this.docker.removeDataDirectory(planned.path, serviceImages[planned.service]);
+        await this.docker.removeDataDirectory(
+          planned.path,
+          serviceImages[planned.service],
+          {
+            projectPath: planned.projectPath,
+            service: planned.service,
+            preDeleteCheck: async () => {
+              const latestProjects = await this.globalRegistry.getAllProjects();
+              const latestEntry = Object.entries(latestProjects).find(
+                ([projectPathArg]) =>
+                  plugins.path.resolve(projectPathArg) === planned.projectPath,
+              )?.[1];
+              if (!latestEntry) {
+                throw new Error(
+                  `Refusing data path without a current activity record: ${planned.path}`,
+                );
+              }
+              const inactiveDays = Math.floor(
+                (Date.now() - latestEntry.lastActive) / dayInMs,
+              );
+              if (inactiveDays <= this.staleDays) {
+                throw new Error(
+                  `Refusing data path for a project that became active: ${planned.path} (${inactiveDays}d)`,
+                );
+              }
+            },
+          },
+        );
         logger.log('ok', `Removed data directory ${planned.path}`);
       }
     }
 
     // Registry metadata last, so a failure above leaves the claim intact.
     for (const projectPath of planArg.registryEntriesToRemove) {
-      if (await plugins.smartfs.directory(projectPath).exists()) {
-        throw new Error(`Refusing to unregister an existing project: ${projectPath}`);
-      }
-      await this.globalRegistry.unregisterProject(projectPath);
-      logger.log('ok', `Unregistered ${projectPath}`);
+      await this.withProjectServiceLocks(projectPath, async () => {
+        if (await plugins.smartfs.directory(projectPath).exists()) {
+          throw new Error(`Refusing to unregister an existing project: ${projectPath}`);
+        }
+        const currentProject = Object.entries(await this.globalRegistry.getAllProjects()).find(
+          ([registeredPathArg]) => plugins.path.resolve(registeredPathArg) === projectPath,
+        )?.[1];
+        if (!currentProject) {
+          return;
+        }
+        if (currentProject.legacy?.minioContainer) {
+          throw new Error(
+            `Refusing to unregister preserved legacy container evidence: ${currentProject.legacy.minioContainer}`,
+          );
+        }
+        const projectContainerIds = await this.docker.listIds([
+          `label=git.zone.project-path=${projectPath}`,
+        ]);
+        if (projectContainerIds.length > 0) {
+          throw new Error(
+            `Refusing to unregister ${projectPath}: a project-labeled container appeared after planning.`,
+          );
+        }
+        for (const containerName of Object.values(currentProject.containers)) {
+          if (!containerName) continue;
+          const ids = await this.docker.listIds([`name=^/${containerName}$`]);
+          if (ids.length > 0) {
+            throw new Error(
+              `Refusing to unregister ${projectPath}: container ${containerName} appeared after planning.`,
+            );
+          }
+        }
+        await this.globalRegistry.unregisterProject(projectPath, currentProject);
+        logger.log('ok', `Unregistered ${projectPath}`);
+      });
     }
   }
 
@@ -521,12 +753,38 @@ export class ServicePruner {
     projectPathArg: string,
   ): Promise<boolean> {
     const projects = await this.globalRegistry.getAllProjects();
-    const claims: string[] = [];
+    const claims: Array<{ projectPath: string; service: TServiceName }> = [];
     for (const [projectPath, project] of Object.entries(projects)) {
-      if (Object.values(project.containers).includes(containerNameArg)) {
-        claims.push(plugins.path.resolve(projectPath));
+      const service = getRegisteredServiceForContainer(project, containerNameArg);
+      if (service) {
+        claims.push({ projectPath: plugins.path.resolve(projectPath), service });
       }
     }
-    return claims.length === 1 && claims[0] === plugins.path.resolve(projectPathArg);
+    return (
+      claims.length === 1 &&
+      claims[0].service !== 'objectstorage' &&
+      claims[0].projectPath === plugins.path.resolve(projectPathArg)
+    );
+  }
+
+  private async withProjectServiceLocks<T>(
+    projectPathArg: string,
+    actionArg: () => Promise<T>,
+    serviceIndexArg = 0,
+  ): Promise<T> {
+    const service = serviceNames[serviceIndexArg];
+    if (!service) {
+      return actionArg();
+    }
+    return withServiceDataOperationLock(projectPathArg, service, () =>
+      this.withProjectServiceLocks(projectPathArg, actionArg, serviceIndexArg + 1),
+    );
+  }
+
+  private async isLegacyContainerReference(containerNameArg: string): Promise<boolean> {
+    const projects = await this.globalRegistry.getAllProjects();
+    return Object.values(projects).some(
+      (project) => project.legacy?.minioContainer === containerNameArg,
+    );
   }
 }