@git.zone/cli 3.2.0 → 4.0.0

package/ts/mod_services/classes.globalregistry.ts

@@ -1,39 +1,40 @@
 import * as plugins from '../plugins.js';
-import { DockerContainer } from './classes.dockercontainer.js';
+import { DockerContainer, type IContainerInspectInfo } from './classes.dockercontainer.js';
 import { logger } from '../gitzone.logging.js';
+import {
+  getServiceContainerLabels,
+  getServiceDataDirectory,
+  hasExactServiceContainerLabels,
+  serviceNames,
+  type TServiceName,
+} from './classes.servicedatamarker.js';
+import { withServiceDataOperationLock } from './classes.interprocesslock.js';
+import {
+  GlobalRegistryStore,
+  assertCanonicalGlobalRegistryData,
+  type IGlobalRegistryData,
+  type IRegisteredProject,
+} from './classes.globalregistrystore.js';
 
-export interface IRegisteredProject {
-  projectPath: string;
-  projectName: string;
-  containers: {
-    mongo?: string;
-    minio?: string;
-    elasticsearch?: string;
-  };
-  ports: {
-    mongo?: number;
-    s3?: number;
-    s3Console?: number;
-    elasticsearch?: number;
-  };
-  enabledServices: string[];
-  lastActive: number;
-}
+export { assertCanonicalGlobalRegistryData } from './classes.globalregistrystore.js';
+export type {
+  IGlobalRegistryData,
+  IRegisteredProject,
+} from './classes.globalregistrystore.js';
 
-export interface IGlobalRegistryData {
-  projects: { [projectPath: string]: IRegisteredProject };
-}
+const registryServiceNames: Record<string, TServiceName> = {
+  mongo: 'mongodb',
+  objectstorage: 'objectstorage',
+  elasticsearch: 'elasticsearch',
+};
 
 export class GlobalRegistry {
   private static instance: GlobalRegistry | null = null;
-  private kvStore: plugins.smartconfig.KeyValueStore<IGlobalRegistryData>;
+  private store: GlobalRegistryStore;
   private docker: DockerContainer;
 
-  private constructor() {
-    this.kvStore = new plugins.smartconfig.KeyValueStore({
-      typeArg: 'userHomeDir',
-      identityArg: 'gitzone-services',
-    });
+  private constructor(storeArg: GlobalRegistryStore = new GlobalRegistryStore()) {
+    this.store = storeArg;
     this.docker = new DockerContainer();
   }
 
@@ -51,49 +52,84 @@ export class GlobalRegistry {
    * Register or update a project in the global registry
    */
   public async registerProject(data: Omit<IRegisteredProject, 'lastActive'>): Promise<void> {
-    const allData = await this.kvStore.readAll();
-    const projects = allData.projects || {};
-
-    projects[data.projectPath] = {
-      ...data,
-      lastActive: Date.now(),
-    };
-
-    await this.kvStore.writeKey('projects', projects);
+    const projectPath = plugins.path.resolve(data.projectPath);
+    await this.store.transact((rawData) => {
+      const allData = assertCanonicalGlobalRegistryData(rawData);
+      const projects = { ...allData.projects };
+      const existingLegacy = projects[projectPath]?.legacy;
+      projects[projectPath] = {
+        ...data,
+        projectPath,
+        ...(existingLegacy ? { legacy: existingLegacy } : {}),
+        lastActive: Date.now(),
+      };
+      return {
+        result: undefined,
+        writeData: { schemaVersion: 2, projects },
+      };
+    });
   }
 
   /**
    * Remove a project from the registry
    */
-  public async unregisterProject(projectPath: string): Promise<void> {
-    const allData = await this.kvStore.readAll();
-    const projects = allData.projects || {};
-
-    if (projects[projectPath]) {
+  public async unregisterProject(
+    projectPathArg: string,
+    expectedProjectArg: IRegisteredProject,
+  ): Promise<void> {
+    const projectPath = plugins.path.resolve(projectPathArg);
+    await this.store.transact((rawData) => {
+      const allData = assertCanonicalGlobalRegistryData(rawData);
+      const projects = { ...allData.projects };
+      const currentProject = projects[projectPath];
+      if (!currentProject) {
+        return { result: undefined };
+      }
+      if (JSON.stringify(currentProject) !== JSON.stringify(expectedProjectArg)) {
+        throw new Error(
+          `Refusing to unregister changed global registry entry: ${projectPath}`,
+        );
+      }
       delete projects[projectPath];
-      await this.kvStore.writeKey('projects', projects);
-    }
+      return {
+        result: undefined,
+        writeData: { schemaVersion: 2, projects },
+      };
+    });
   }
 
   /**
    * Update the lastActive timestamp for a project
    */
   public async touchProject(projectPath: string): Promise<void> {
-    const allData = await this.kvStore.readAll();
-    const projects = allData.projects || {};
-
-    if (projects[projectPath]) {
-      projects[projectPath].lastActive = Date.now();
-      await this.kvStore.writeKey('projects', projects);
-    }
+    const resolvedProjectPath = plugins.path.resolve(projectPath);
+    await this.store.transact((rawData) => {
+      const allData = assertCanonicalGlobalRegistryData(rawData);
+      const projects = { ...allData.projects };
+      const existing = projects[resolvedProjectPath];
+      if (!existing) {
+        return { result: undefined };
+      }
+      projects[resolvedProjectPath] = {
+        ...existing,
+        lastActive: Date.now(),
+      };
+      return {
+        result: undefined,
+        writeData: { schemaVersion: 2, projects },
+      };
+    });
   }
 
   /**
    * Get all registered projects
    */
   public async getAllProjects(): Promise<{ [path: string]: IRegisteredProject }> {
-    const allData = await this.kvStore.readAll();
-    return allData.projects || {};
+    return (await this.readCanonicalData()).projects;
+  }
+
+  private async readCanonicalData(): Promise<IGlobalRegistryData> {
+    return this.store.readCanonical();
   }
 
   /**
@@ -101,7 +137,7 @@ export class GlobalRegistry {
    */
   public async isRegistered(projectPath: string): Promise<boolean> {
     const projects = await this.getAllProjects();
-    return !!projects[projectPath];
+    return !!projects[plugins.path.resolve(projectPath)];
   }
 
   /**
@@ -111,7 +147,11 @@ export class GlobalRegistry {
     Array<{
       projectPath: string;
       projectName: string;
-      containers: Array<{ name: string; status: string }>;
+      containers: Array<{
+        name: string;
+        status: string;
+        ownership?: 'owned' | 'conflict';
+      }>;
       lastActive: number;
     }>
   > {
@@ -119,15 +159,48 @@ export class GlobalRegistry {
     const result: Array<{
       projectPath: string;
       projectName: string;
-      containers: Array<{ name: string; status: string }>;
+      containers: Array<{
+        name: string;
+        status: string;
+        ownership?: 'owned' | 'conflict';
+      }>;
       lastActive: number;
     }> = [];
 
     for (const [path, project] of Object.entries(projects)) {
-      const containerStatuses: Array<{ name: string; status: string }> = [];
+      const containerStatuses: Array<{
+        name: string;
+        status: string;
+        ownership?: 'owned' | 'conflict';
+      }> = [];
 
-      for (const containerName of Object.values(project.containers)) {
+      for (const [serviceKey, containerName] of Object.entries(project.containers)) {
         if (containerName) {
+          if (serviceKey === 'objectstorage') {
+            const objectStorage = await this.inspectRegisteredContainer(
+              project,
+              containerName,
+            );
+            if (!objectStorage) {
+              containerStatuses.push({ name: containerName, status: 'not_exists' });
+              continue;
+            }
+            const expectedLabels = getServiceContainerLabels({
+              projectPath: project.projectPath,
+              service: 'objectstorage',
+              dataPath: getServiceDataDirectory(project.projectPath, 'objectstorage'),
+            });
+            const owned = hasExactServiceContainerLabels(
+              objectStorage.labels,
+              expectedLabels,
+            );
+            containerStatuses.push({
+              name: containerName,
+              status: objectStorage.state,
+              ownership: owned ? 'owned' : 'conflict',
+            });
+            continue;
+          }
           const status = await this.docker.getStatus(containerName);
           containerStatuses.push({ name: containerName, status });
         }
@@ -153,13 +226,75 @@ export class GlobalRegistry {
     const failed: string[] = [];
 
     for (const project of Object.values(projects)) {
-      for (const containerName of Object.values(project.containers)) {
+      for (const [serviceKey, containerName] of Object.entries(project.containers)) {
         if (containerName) {
-          const status = await this.docker.getStatus(containerName);
-          if (status === 'running') {
-            if (await this.docker.stop(containerName)) {
-              stopped.push(containerName);
-            } else {
+          const service = registryServiceNames[serviceKey];
+          if (!service) {
+            failed.push(containerName);
+            continue;
+          }
+          try {
+            await withServiceDataOperationLock(project.projectPath, service, async () => {
+              const currentProjects = await this.getAllProjects();
+              const claims: Array<{ projectPath: string; service: TServiceName }> = [];
+              for (const [registeredPathArg, registeredProjectArg] of Object.entries(
+                currentProjects,
+              )) {
+                for (const [registeredServiceKeyArg, registeredNameArg] of Object.entries(
+                  registeredProjectArg.containers,
+                )) {
+                  const registeredService = registryServiceNames[registeredServiceKeyArg];
+                  if (registeredService && registeredNameArg === containerName) {
+                    claims.push({
+                      projectPath: plugins.path.resolve(registeredPathArg),
+                      service: registeredService,
+                    });
+                  }
+                }
+              }
+              const projectPath = plugins.path.resolve(project.projectPath);
+              const currentProject = Object.entries(currentProjects).find(
+                ([registeredPathArg]) =>
+                  plugins.path.resolve(registeredPathArg) === projectPath,
+              )?.[1];
+              if (!currentProject || currentProject.containers[serviceKey] !== containerName) {
+                throw new Error('Registry container claim changed before stop');
+              }
+              const inspection = await this.inspectRegisteredContainer(
+                currentProject,
+                containerName,
+              );
+              if (!inspection) {
+                return;
+              }
+              const expectedLabels = getServiceContainerLabels({
+                projectPath,
+                service,
+                dataPath: getServiceDataDirectory(projectPath, service),
+              });
+              const labelOwned = hasExactServiceContainerLabels(
+                inspection.labels,
+                expectedLabels,
+              );
+              const hasGitZoneLabels = Object.keys(inspection.labels).some((keyArg) =>
+                keyArg.startsWith('git.zone.'),
+              );
+              const registryOwned =
+                service !== 'objectstorage' &&
+                !hasGitZoneLabels &&
+                claims.length === 1 &&
+                claims[0].projectPath === projectPath &&
+                claims[0].service === service;
+              if (!labelOwned && !registryOwned) {
+                throw new Error('Container ownership conflict');
+              }
+              if (inspection.running) {
+                await this.docker.execArgv(['stop', inspection.id], { timeoutMs: 60_000 });
+                stopped.push(containerName);
+              }
+            });
+          } catch {
+            if (!failed.includes(containerName)) {
               failed.push(containerName);
             }
           }
@@ -170,6 +305,41 @@ export class GlobalRegistry {
     return { stopped, failed };
   }
 
+  private async inspectRegisteredContainer(
+    projectArg: IRegisteredProject,
+    containerNameArg: string,
+  ): Promise<IContainerInspectInfo | undefined> {
+    const ids = await this.docker.listIds([`name=^/${containerNameArg}$`]);
+    if (ids.length === 0) {
+      return undefined;
+    }
+    const inspections = (await this.docker.inspectMany(ids)).filter(
+      (inspection) => inspection.name === containerNameArg,
+    );
+    if (inspections.length !== 1) {
+      throw new Error(
+        `Docker returned ambiguous ObjectStorage identity for ${projectArg.projectPath}.`,
+      );
+    }
+    return inspections[0];
+  }
+
+  private async exactContainerExists(containerNameArg: string): Promise<boolean> {
+    const ids = await this.docker.listIds([`name=^/${containerNameArg}$`]);
+    if (ids.length === 0) {
+      return false;
+    }
+    const inspections = (await this.docker.inspectMany(ids)).filter(
+      (inspection) => inspection.name === containerNameArg,
+    );
+    if (inspections.length !== 1) {
+      throw new Error(
+        `Docker returned ambiguous container identity for ${containerNameArg}.`,
+      );
+    }
+    return true;
+  }
+
   /**
    * Cheap staleness summary for a non-blocking hint after ordinary commands.
    *
@@ -205,38 +375,69 @@ export class GlobalRegistry {
     const removed: string[] = [];
     const kept: Array<{ projectPath: string; reason: string }> = [];
 
-    for (const [projectPath, project] of Object.entries(projects)) {
-      if (await plugins.smartfs.directory(projectPath).exists()) {
-        continue;
-      }
-
-      // Same rule ServicePruner enforces: for containers created before labels
-      // existed, this registry entry is the only thing that can still identify
-      // them. Dropping it while one exists would hide the container from prune,
-      // `stop -g` and `cleanup -g` alike, leaving it running forever under
-      // `restart: unless-stopped`.
-      const survivingContainers: string[] = [];
-      for (const containerName of Object.values(project.containers)) {
-        if (!containerName) {
-          continue;
+    for (const projectPath of Object.keys(projects)) {
+      await this.withProjectServiceLocks(projectPath, async () => {
+        if (await plugins.smartfs.directory(projectPath).exists()) {
+          return;
         }
-        if ((await this.docker.getStatus(containerName)) !== 'not_exists') {
-          survivingContainers.push(containerName);
+        const currentProject = Object.entries(await this.getAllProjects()).find(
+          ([registeredPathArg]) =>
+            plugins.path.resolve(registeredPathArg) === plugins.path.resolve(projectPath),
+        )?.[1];
+        if (!currentProject) {
+          return;
+        }
+        if (currentProject.legacy?.minioContainer) {
+          kept.push({
+            projectPath,
+            reason: `preserved legacy MinIO container reference: ${currentProject.legacy.minioContainer}`,
+          });
+          return;
         }
-      }
 
-      if (survivingContainers.length > 0) {
-        kept.push({
-          projectPath,
-          reason: `container(s) still exist: ${survivingContainers.join(', ')}`,
-        });
-        continue;
-      }
+        // Same rule ServicePruner enforces: for containers created before labels
+        // existed, this registry entry is the only thing that can still identify
+        // them. Re-read under all service locks so a concurrent start cannot
+        // appear between the Docker check and compare-delete.
+        const survivingContainers: string[] = [];
+        for (const containerName of Object.values(currentProject.containers)) {
+          if (containerName && (await this.exactContainerExists(containerName))) {
+            survivingContainers.push(containerName);
+          }
+        }
+        const labeledIds = await this.docker.listIds([
+          `label=git.zone.project-path=${plugins.path.resolve(projectPath)}`,
+        ]);
+        if (labeledIds.length > 0) {
+          survivingContainers.push('project-labeled container');
+        }
+        if (survivingContainers.length > 0) {
+          kept.push({
+            projectPath,
+            reason: `container(s) still exist: ${survivingContainers.join(', ')}`,
+          });
+          return;
+        }
 
-      await this.unregisterProject(projectPath);
-      removed.push(projectPath);
+        await this.unregisterProject(projectPath, currentProject);
+        removed.push(projectPath);
+      });
     }
 
     return { removed, kept };
   }
+
+  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),
+    );
+  }
 }