@foss.global/gitmanager 1.5.0 → 1.7.0

package/ts/models.ts

@@ -75,6 +75,10 @@ export interface IGitManagerRepositoryArchiveRequest
   objectId: string;
 }
 
+export interface IGitManagerRepositoryArchiveOptions {
+  signal?: AbortSignal;
+}
+
 export interface IGitManagerRepositoryArchive
   extends IGitManagerRepositorySelector {
   objectId: string;
@@ -182,6 +186,32 @@ export interface IGitManagerStatus {
   smartHttp?: IGitManagerSmartHttpStatus;
 }
 
+export interface IGitManagerReadinessOptions {
+  timeoutMs?: number;
+  signal?: AbortSignal;
+}
+
+export type TGitManagerReadinessFailureReason =
+  | 'not_running'
+  | 'starting'
+  | 'stopping'
+  | 'aborted'
+  | 'timeout'
+  | 'unavailable';
+
+export type TGitManagerReadinessResult =
+  | {
+      ready: true;
+      status: 'ready';
+      durationMs: number;
+    }
+  | {
+      ready: false;
+      status: 'unavailable';
+      reason: TGitManagerReadinessFailureReason;
+      durationMs: number;
+    };
+
 export type {
   IGitManagerCommitDetail,
   IGitManagerCommitRequest,

package/ts/plugins.ts

@@ -1,11 +1,13 @@
 // node native scope
 import * as childProcess from 'node:child_process';
+import * as crypto from 'node:crypto';
 import { EventEmitter } from 'node:events';
+import * as http from 'node:http';
 import * as path from 'node:path';
 import * as stream from 'node:stream';
 import * as url from 'node:url';
 
-export { childProcess, EventEmitter, path, stream, url };
+export { childProcess, crypto, EventEmitter, http, path, stream, url };
 
 // @push.rocks scope
 import * as smartrust from '@push.rocks/smartrust';

package/ts/rust-gitmanager-bridge.ts

@@ -19,6 +19,7 @@ import type {
   IGitManagerSmartHttpRepositoryProtectedRefs,
   IGitManagerRepositoryBundle,
   IGitManagerRepositoryArchive,
+  IGitManagerRepositoryArchiveOptions,
   IGitManagerRepositoryArchiveRequest,
   IGitManagerRepositoryLfsPointer,
   IGitManagerRepositoryServiceRequest,
@@ -36,6 +37,21 @@ import type {
   IRustGitManagerRepositoryServiceDescriptor,
 } from './models.js';
 
+type TRepositoryArchiveCancelStatus =
+  | 'cancelled'
+  | 'completed'
+  | 'failed'
+  | 'not_found';
+
+interface IRepositoryArchiveOperationRequest {
+  operationId: string;
+  request: IGitManagerRepositoryArchiveRequest;
+}
+
+interface IRepositoryArchiveCancelRequest {
+  operationId: string;
+}
+
 type TGitManagerCommands = {
   start: { params: { config: IRustGitManagerConfig }; result: Record<string, never> };
   stop: { params: Record<string, never>; result: Record<string, never> };
@@ -48,7 +64,8 @@ type TGitManagerCommands = {
   refreshMirror: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryInfo };
   verifyRepository: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryInfo };
   createRepositoryBundle: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryBundle };
-  createRepositoryArchive: { params: IGitManagerRepositoryArchiveRequest; result: IGitManagerRepositoryArchive };
+  createRepositoryArchive: { params: IRepositoryArchiveOperationRequest; result: IGitManagerRepositoryArchive };
+  cancelRepositoryArchive: { params: IRepositoryArchiveCancelRequest; result: { status: TRepositoryArchiveCancelStatus } };
   prepareRepositoryService: { params: IGitManagerRepositoryServiceRequest; result: IRustGitManagerRepositoryServiceDescriptor };
   restoreRepositoryBundle: { params: IGitManagerRestoreBundleRequest; result: IGitManagerRepositoryInfo };
   listRepositories: { params: Record<string, never>; result: IGitManagerRepositoryInfo[] };
@@ -122,6 +139,10 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     this.bridge.kill();
   }
 
+  public async terminate(): Promise<void> {
+    await this.bridge.terminate();
+  }
+
   public get running(): boolean {
     return this.bridge.running;
   }
@@ -134,8 +155,10 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
     await this.bridge.sendCommand('stop', {});
   }
 
-  public async getStatus(): Promise<IGitManagerStatus> {
-    return this.bridge.sendCommand('getStatus', {});
+  public async getStatus(
+    optionsArg?: plugins.smartrust.IRustBridgeRequestOptions,
+  ): Promise<IGitManagerStatus> {
+    return this.bridge.sendCommand('getStatus', {}, optionsArg);
   }
 
   public async setSmartHttpRepositoryAccess(accessArg: IGitManagerSmartHttpRepositoryAccess): Promise<void> {
@@ -181,10 +204,52 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
 
   public async createRepositoryArchive(
     requestArg: IGitManagerRepositoryArchiveRequest,
+    optionsArg: IGitManagerRepositoryArchiveOptions = {},
   ): Promise<IGitManagerRepositoryArchive> {
-    const result = await this.bridge.sendCommand('createRepositoryArchive', requestArg, {
+    if (optionsArg.signal?.aborted) {
+      throw optionsArg.signal.reason ?? new Error('Repository archive creation was aborted.');
+    }
+    const operationId = plugins.crypto.randomUUID();
+    const archivePromise = this.bridge.sendCommand('createRepositoryArchive', {
+      operationId,
+      request: requestArg,
+    }, {
       timeoutMs: 65 * 60 * 1000,
     });
+    let cancelPromise:
+      | Promise<{ status: TRepositoryArchiveCancelStatus }>
+      | undefined;
+    const cancelArchive = (): void => {
+      cancelPromise ??= this.bridge.sendCommand('cancelRepositoryArchive', {
+        operationId,
+      }, {
+        timeoutMs: 65 * 60 * 1000,
+      });
+    };
+    optionsArg.signal?.addEventListener('abort', cancelArchive, { once: true });
+    if (optionsArg.signal?.aborted) {
+      cancelArchive();
+    }
+
+    let result: IGitManagerRepositoryArchive;
+    try {
+      result = await archivePromise;
+      if (cancelPromise) {
+        await cancelPromise.catch(() => undefined);
+      }
+    } catch (archiveError) {
+      if (!cancelPromise) {
+        throw archiveError;
+      }
+      const cancellation = await cancelPromise;
+      if (cancellation.status === 'cancelled') {
+        throw optionsArg.signal?.reason
+          ?? new Error('Repository archive creation was aborted.');
+      }
+      throw archiveError;
+    } finally {
+      optionsArg.signal?.removeEventListener('abort', cancelArchive);
+    }
     for (const [field, value] of [
       ['sizeBytes', result.sizeBytes],
       ['extractedSizeBytes', result.extractedSizeBytes],