Class VaultInternal

Protected db

Protected efs

Protected efsVault

Protected keyRing

Protected lock

Protected logger

Protected vaultMetadataDbPath

Protected vaultsDbPath

Protected vaultsNamesPath

Protected cleanWorkingDirectory

• cleanWorkingDirectory(ctx): Promise<void>

• Cleans the git working directory by checking out the canonical branch. This will remove any un-committed changes since any untracked or modified files outside a commit is dirty state. Dirty state should only happen if the usual commit procedure was interrupted ungracefully.

  Parameters

  • ctx: ContextTimed

  Returns Promise<void>

Protected createCommit

• createCommit(ctx): Promise<void>

• Creates a commit while moving the canonicalBranch reference to that new commit. If the commit creates a branch from the canonical history. Then the new commit becomes the new canonical history and the old history is removed from the old canonical head to the branch point. This is to maintain the strict non-branching linear history.

  Parameters

  • ctx: ContextTimed

  Returns Promise<void>

Protected destroy_

• destroy_(tran): Promise<void>

• We use a protected destroy method to avoid the async-init lifecycle deadlocking when doing the recursive call to create a DBTransaction.

  Parameters

  • tran: DBTransaction

  Returns Promise<void>

Protected garbageCollectGitObjectsGlobal

• garbageCollectGitObjectsGlobal(ctx): Promise<void>

• This will walk the current canonical branch history and delete any objects that are not a part of it. This is costly since it will compare the walked tree with all existing objects.

  Parameters

  • ctx: ContextTimed

  Returns Promise<void>

Protected garbageCollectGitObjectsLocal

• garbageCollectGitObjectsLocal(startId, stopId, ctx): Promise<void>

• This will walk from the startId to the StopId deleting objects as it goes. This is smarter since it only walks over the old history and not everything.

  Parameters

  • startId: string

  • stopId: string

  • ctx: ContextTimed

  Returns Promise<void>

Protected request

• request(client, vaultNameOrId, vaultAction): Promise<any[]>

• Creates a request arrow function that implements an API that isomorphic-git expects to use when making a HTTP request. It makes RPC calls to vaultsGitInfoGet for the ref advertisement phase and vaultsGitPackGet for the git pack phase.

  vaultsGitInfoGet wraps a call to gitHttp.advertiseRefGenerator and vaultsGitPackGet to gitHttp.generatePackRequest.

                                   ┌─────────┐    ┌───────────────────────────┐
                                   │         │    │                           │
   ┌──────────────────────┐        │  RPC    │    │                           │
   │                      │        │         │    │ *advertiseRefGenerator()  │
   │                      ├────────┼─────────┼────▶                           │
   │     vault.request()  │        │         │    │                           │
   │                      │        │         │    └────┬──────────────────────┘
   │                      ├──┐     │         │         │
   │                      │  │     │         │    ┌────▼──────────────────────┐
   └──────────────────────┘  │     │         │    │                           │
                             │     │         │    │ *referenceListGenerator() │
                             │     │         │    │                           │
                             │     │         │    └───────────────────────────┘
                             │     │         │
                             │     │         │    ┌───────────────────────────┐
                             └─────┼─────────┼────┤                           │
                                   │         │    │ *generatePackRequest()    │
                                   │         │    │                           │
                                   │         │    └────┬──────────────────────┘
                                   └─────────┘         │
                                                  ┌────▼──────────────────────┐
                                                  │                           │
                                                  │ *generatePackData()       │
                                                  │                           │
                                                  └───────────────────────────┘
  
  Copy

  Parameters

  • client: RPCClient<{
        nodesAuditEventsGet: ServerCaller<AgentRPCRequestParams<AuditIdMessage>, AgentRPCResponseResult<AgentAuditMessage<AuditEvent>>>;
        nodesAuthenticateConnection: UnaryCaller<AgentRPCRequestParams<NodesAuthenticateConnectionMessage>, AgentRPCResponseResult<nodes.agent.types.SuccessMessage>>;
        nodesClaimNetworkSign: UnaryCaller<AgentRPCRequestParams<AgentClaimMessage>, AgentRPCResponseResult<AgentClaimMessage>>;
        nodesClaimNetworkVerify: UnaryCaller<AgentRPCRequestParams<AgentClaimMessage>, AgentRPCResponseResult<{
            success: true;
        }>>;
        nodesClaimsGet: ServerCaller<AgentRPCRequestParams<NodesClaimsGetMessage>, AgentRPCResponseResult<AgentClaimMessage>>;
        nodesClosestActiveConnectionsGet: ServerCaller<AgentRPCRequestParams<nodes.agent.types.NodeIdMessage>, AgentRPCResponseResult<ActiveConnectionDataMessage>>;
        nodesClosestLocalNodesGet: ServerCaller<AgentRPCRequestParams<nodes.agent.types.NodeIdMessage>, AgentRPCResponseResult<NodeContactMessage>>;
        nodesConnectionSignalFinal: UnaryCaller<AgentRPCRequestParams<HolePunchRequestMessage>, AgentRPCResponseResult>;
        nodesConnectionSignalInitial: UnaryCaller<AgentRPCRequestParams<HolePunchSignalMessage>, AgentRPCResponseResult<nodes.agent.types.AddressMessage>>;
        nodesCrossSignClaim: DuplexCaller<AgentRPCRequestParams<AgentClaimMessage>, AgentRPCResponseResult<AgentClaimMessage>>;
        notificationsSend: UnaryCaller<AgentRPCRequestParams<SignedNotificationEncoded>, AgentRPCResponseResult>;
        vaultsGitInfoGet: RawCaller;
        vaultsGitPackGet: RawCaller;
        vaultsScan: ServerCaller<AgentRPCRequestParams, AgentRPCResponseResult<nodes.agent.types.VaultsScanMessage>>;
    }>

  • vaultNameOrId: string | VaultId

  • vaultAction: "clone" | "pull"

  Returns Promise<any[]>

Protected setupGit

• setupGit(tran, ctx): Promise<string>

• Does an idempotent initialization of the git repository for the vault. If the vault is in a dirty state then we clean up the working directory or any history not part of the canonical branch.

  Parameters

  • tran: DBTransaction

  • ctx: ContextTimed

  Returns Promise<string>

Protected setupMeta

• setupMeta(__namedParameters, tran): Promise<void>

• Sets up the vault metadata. Creates a dirty boolean in the database to track dirty state of the vault. Also adds the vault's name to the database.

  Parameters

  • __namedParameters: {
        vaultName?: string;
    }

    • Optional vaultName?: string

  • tran: DBTransaction

  Returns Promise<void>

Protected start_

• start_(__namedParameters, tran, ctx?): Promise<void>

• We use a protected start method to avoid the async-init lifecycle deadlocking when doing the recursive call to create a DBTransaction.

  Parameters

  • __namedParameters: {
        fresh: boolean;
        vaultName?: string;
    }

    • fresh: boolean

    • Optional vaultName?: string

  • tran: DBTransaction

  • Optional ctx: Partial<ContextTimedInput>

  Returns Promise<void>