@foss.global/gitmanager 2.2.0 → 2.4.0

package/ts/rust-gitmanager-bridge.ts

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 import { GitManagerError, isGitManagerErrorCode } from './classes.gitmanagererror.js';
 import type {
   IGitManagerAncestryRequest,
+  IGitManagerAtomicPushRequest,
+  IGitManagerAtomicPushResult,
   IGitManagerCommitDetail,
   IGitManagerCommitRequest,
   IGitManagerCommitSummary,
@@ -16,6 +18,7 @@ import type {
   IGitManagerMergeResult,
   IGitManagerReadFileRequest,
   IGitManagerRefRequest,
+  IGitManagerRefreshMirrorRequest,
   IGitManagerProtectedRefsApplyResult,
   IGitManagerSmartHttpRepositoryProtectedRefs,
   IGitManagerRepositoryBundle,
@@ -23,10 +26,11 @@ import type {
   IGitManagerRepositoryArchiveOptions,
   IGitManagerRepositoryArchiveRequest,
   IGitManagerRepositoryLfsPointer,
-  IGitManagerRepositoryServiceRequest,
   IGitManagerRepositoryInfo,
   IGitManagerRepositorySelector,
+  IGitManagerRepositorySize,
   IGitManagerRestoreBundleRequest,
+  IGitManagerSetDefaultBranchRequest,
   IGitManagerSmartHttpRepositoryAccess,
   IGitManagerSmartHttpRepositoryVisibility,
   IGitManagerStatus,
@@ -34,9 +38,11 @@ import type {
   IGitManagerTagRequest,
   IGitManagerTreeEntry,
   IGitManagerTreeRequest,
+  IGitManagerTransferControlOptions,
   IRustGitManagerConfig,
   TGitManagerRefInventoryResult,
   IRustGitManagerRepositoryServiceDescriptor,
+  IRustGitManagerRepositoryServicePrepareRequest,
 } from './models.js';
 
 type TRepositoryArchiveCancelStatus =
@@ -54,6 +60,14 @@ interface IRepositoryArchiveCancelRequest {
   operationId: string;
 }
 
+/** A remote transfer under the operation ID that `cancelTransfer` names. */
+interface ITransferOperationRequest<TRequest> {
+  operationId: string;
+  request: TRequest;
+}
+
+type TTransferCancelStatus = 'cancelling' | 'not_found';
+
 type TGitManagerCommands = {
   start: { params: { config: IRustGitManagerConfig }; result: Record<string, never> };
   stop: { params: Record<string, never>; result: Record<string, never> };
@@ -62,13 +76,27 @@ type TGitManagerCommands = {
   setSmartHttpRepositoryVisibility: { params: IGitManagerSmartHttpRepositoryVisibility; result: Record<string, never> };
   setSmartHttpRepositoryProtectedRefs: { params: IGitManagerSmartHttpRepositoryProtectedRefs; result: IGitManagerProtectedRefsApplyResult };
   initBareRepository: { params: IGitManagerInitBareRepositoryRequest; result: IGitManagerRepositoryInfo };
-  importMirror: { params: IGitManagerImportMirrorRequest; result: IGitManagerRepositoryInfo };
-  refreshMirror: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryInfo };
+  importMirror: {
+    params: ITransferOperationRequest<IGitManagerImportMirrorRequest>;
+    result: IGitManagerRepositoryInfo;
+  };
+  refreshMirror: {
+    params: ITransferOperationRequest<IGitManagerRefreshMirrorRequest>;
+    result: IGitManagerRepositoryInfo;
+  };
+  pushRefs: {
+    params: ITransferOperationRequest<IGitManagerAtomicPushRequest>;
+    result: IGitManagerAtomicPushResult;
+  };
+  cancelTransfer: { params: { operationId: string }; result: { status: TTransferCancelStatus } };
+  setDefaultBranch: { params: IGitManagerSetDefaultBranchRequest; result: IGitManagerRepositoryInfo };
   verifyRepository: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryInfo };
+  getRepositorySize: { params: IGitManagerRepositorySelector; result: IGitManagerRepositorySize };
   createRepositoryBundle: { params: IGitManagerRepositorySelector; result: IGitManagerRepositoryBundle };
   createRepositoryArchive: { params: IRepositoryArchiveOperationRequest; result: IGitManagerRepositoryArchive };
   cancelRepositoryArchive: { params: IRepositoryArchiveCancelRequest; result: { status: TRepositoryArchiveCancelStatus } };
-  prepareRepositoryService: { params: IGitManagerRepositoryServiceRequest; result: IRustGitManagerRepositoryServiceDescriptor };
+  prepareRepositoryService: { params: IRustGitManagerRepositoryServicePrepareRequest; result: IRustGitManagerRepositoryServiceDescriptor };
+  releaseRepositoryService: { params: { ticketId: string }; result: { released: boolean } };
   restoreRepositoryBundle: { params: IGitManagerRestoreBundleRequest; result: IGitManagerRepositoryInfo };
   listRepositories: { params: Record<string, never>; result: IGitManagerRepositoryInfo[] };
   listRefs: { params: IGitManagerRefRequest; result: TGitManagerRefInventoryResult };
@@ -84,6 +112,19 @@ type TGitManagerCommands = {
   getTag: { params: IGitManagerTagRequest; result: IGitManagerTag };
 };
 
+/** Engine default for a remote transfer without `timeoutMs`. */
+const defaultRemoteTransferTimeoutMs = 120_000;
+
+/**
+ * The bridge waits past the engine's own transfer limit, so the engine reports
+ * a timeout and cleans up before the request is abandoned.
+ */
+const remoteTransferResponseTimeoutMs = (timeoutMsArg: number | undefined): number =>
+  (timeoutMsArg ?? defaultRemoteTransferTimeoutMs) + 30_000;
+
+/** The cancel command is answered at once; the transfer reports its own end. */
+const transferCancelTimeoutMs = 30_000;
+
 function getPackageRoot(): string {
   const thisDir = plugins.path.dirname(plugins.url.fileURLToPath(import.meta.url));
   return plugins.path.resolve(thisDir, '..');
@@ -214,15 +255,79 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
   }
 
   public async initBareRepository(requestArg: IGitManagerInitBareRepositoryRequest): Promise<IGitManagerRepositoryInfo> {
-    return this.bridge.sendCommand('initBareRepository', requestArg);
+    return this.bridge.sendCommand('initBareRepository', requestArg).catch(rethrowCodedError);
   }
 
-  public async importMirror(requestArg: IGitManagerImportMirrorRequest): Promise<IGitManagerRepositoryInfo> {
-    return this.bridge.sendCommand('importMirror', requestArg);
+  public async importMirror(
+    requestArg: IGitManagerImportMirrorRequest,
+    optionsArg: IGitManagerTransferControlOptions = {},
+  ): Promise<IGitManagerRepositoryInfo> {
+    return this.runTransfer('importMirror', requestArg, optionsArg);
   }
 
-  public async refreshMirror(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryInfo> {
-    return this.bridge.sendCommand('refreshMirror', requestArg);
+  public async refreshMirror(
+    requestArg: IGitManagerRefreshMirrorRequest,
+    optionsArg: IGitManagerTransferControlOptions = {},
+  ): Promise<IGitManagerRepositoryInfo> {
+    return this.runTransfer('refreshMirror', requestArg, optionsArg);
+  }
+
+  public async pushRefs(
+    requestArg: IGitManagerAtomicPushRequest,
+    optionsArg: IGitManagerTransferControlOptions = {},
+  ): Promise<IGitManagerAtomicPushResult> {
+    return this.runTransfer('pushRefs', requestArg, optionsArg);
+  }
+
+  /**
+   * Runs a remote transfer under a fresh operation ID. Aborting the signal
+   * sends `cancelTransfer`; the engine then terminates the transfer's Git
+   * process and answers the transfer itself with `transferAborted`. A signal
+   * that is already aborted rejects before anything is sent.
+   */
+  private async runTransfer<TMethod extends 'importMirror' | 'refreshMirror' | 'pushRefs'>(
+    methodArg: TMethod,
+    requestArg: TGitManagerCommands[TMethod]['params']['request'],
+    optionsArg: IGitManagerTransferControlOptions,
+  ): Promise<TGitManagerCommands[TMethod]['result']> {
+    const signal = optionsArg.signal;
+    if (signal?.aborted) {
+      throw new GitManagerError('transferAborted', 'The transfer was aborted before it started', {
+        cause: signal.reason,
+      });
+    }
+    const operationId = plugins.crypto.randomUUID();
+    const params = { operationId, request: requestArg } as TGitManagerCommands[TMethod]['params'];
+    const transfer = this.bridge.sendCommand(methodArg, params, {
+      timeoutMs: remoteTransferResponseTimeoutMs(requestArg.timeoutMs),
+    });
+    const cancelTransfer = (): void => {
+      // Only the transfer's own response settles the call.
+      void this.bridge.sendCommand('cancelTransfer', { operationId }, {
+        timeoutMs: transferCancelTimeoutMs,
+      }).catch(() => undefined);
+    };
+    signal?.addEventListener('abort', cancelTransfer, { once: true });
+    try {
+      return await transfer;
+    } catch (error) {
+      return rethrowCodedError(error);
+    } finally {
+      signal?.removeEventListener('abort', cancelTransfer);
+    }
+  }
+
+  public async setDefaultBranch(
+    requestArg: IGitManagerSetDefaultBranchRequest,
+  ): Promise<IGitManagerRepositoryInfo> {
+    return this.bridge.sendCommand('setDefaultBranch', requestArg).catch(rethrowCodedError);
+  }
+
+  public async getRepositorySize(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositorySize> {
+    // The engine measures for up to 30 minutes.
+    return this.bridge.sendCommand('getRepositorySize', requestArg, {
+      timeoutMs: 31 * 60 * 1000,
+    });
   }
 
   public async verifyRepository(requestArg: IGitManagerRepositorySelector): Promise<IGitManagerRepositoryInfo> {
@@ -296,15 +401,20 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
   }
 
   public async prepareRepositoryService(
-    requestArg: IGitManagerRepositoryServiceRequest,
+    requestArg: IRustGitManagerRepositoryServicePrepareRequest,
   ): Promise<IRustGitManagerRepositoryServiceDescriptor> {
-    return this.bridge.sendCommand('prepareRepositoryService', requestArg);
+    return this.bridge.sendCommand('prepareRepositoryService', requestArg).catch(rethrowCodedError);
+  }
+
+  /** Releases a receive-pack guard ticket; unknown or released tickets are a no-op. */
+  public async releaseRepositoryService(ticketIdArg: string): Promise<void> {
+    await this.bridge.sendCommand('releaseRepositoryService', { ticketId: ticketIdArg });
   }
 
   public async restoreRepositoryBundle(
     requestArg: IGitManagerRestoreBundleRequest,
   ): Promise<IGitManagerRepositoryInfo> {
-    return this.bridge.sendCommand('restoreRepositoryBundle', requestArg);
+    return this.bridge.sendCommand('restoreRepositoryBundle', requestArg).catch(rethrowCodedError);
   }
 
   public async listRepositories(): Promise<IGitManagerRepositoryInfo[]> {
@@ -326,7 +436,7 @@ export class RustGitManagerBridge extends plugins.EventEmitter {
   public async mergeRepository(
     requestArg: IGitManagerMergeRequest,
   ): Promise<IGitManagerMergeResult> {
-    return this.bridge.sendCommand('mergeRepository', requestArg);
+    return this.bridge.sendCommand('mergeRepository', requestArg).catch(rethrowCodedError);
   }
 
   public async listTree(requestArg: IGitManagerTreeRequest): Promise<IGitManagerTreeEntry[]> {