FilesExpand file tree

main

/

remote-ref-probe-cache.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

130 lines (120 loc) · 4.34 KB

main

/

remote-ref-probe-cache.ts

Copy path

Top

File metadata and controls

• Code
• Blame

130 lines (120 loc) · 4.34 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

import { runCoalescedProbe, type CoalescedProbes } from './coalesced-probe'

import { isTransientGitProbeError, readRemoteUrl } from './remote-url-probe'

import type { GitAdmissionTier } from './command-runner/git-exec-options'

/**

* The "is this repo mine?" probe every forge integration runs: read the remote's

* URL once per repo/runtime, cache what the provider's parser made of it, and

* never cache an answer a failed probe never gave.

*/

const REPO_REF_CACHE_MAX_ENTRIES = 512

/**

* Why: "not this provider" only holds until someone edits the repo's remotes —

* and a repo first probed before it had any remote answers that way too.

* Nothing here watches `.git/config`, and a watcher cannot cover the SSH and WSL

* runtimes this cache also serves, so negatives expire instead: one probe per

* repo per interval is what lets a remote added mid-session be picked up without

* a restart. Positives stay, as they did before.

*/

export const NEGATIVE_ENTRY_TTL_MS = 5 * 60_000

type CachedRepoRef<Ref> = { value: Ref | null; expiresAt: number }

export type RemoteRefLocalGitOptions = {

wslDistro?: string

admissionTier?: GitAdmissionTier

}

export type RemoteRefProbeCache<Ref> = {

get(

repoPath: string,

remoteName: string,

connectionId?: string | null,

localGitOptions?: RemoteRefLocalGitOptions

): Promise<Ref | null>

clear(): void

size(): number

}

export function createRemoteRefProbeCache<Ref>(

parseRemoteUrl: (remoteUrl: string) => Ref | null

): RemoteRefProbeCache<Ref> {

const repoRefCache = new Map<string, CachedRepoRef<Ref>>()

const inFlight: CoalescedProbes<Ref | null> = new Map()

function remember(cacheKey: string, value: Ref | null): void {

repoRefCache.set(cacheKey, {

value,

expiresAt: value === null ? Date.now() + NEGATIVE_ENTRY_TTL_MS : Number.POSITIVE_INFINITY

})

while (repoRefCache.size > REPO_REF_CACHE_MAX_ENTRIES) {

const oldestKey = repoRefCache.keys().next().value

if (oldestKey === undefined) {

return

}

repoRefCache.delete(oldestKey)

}

}

async function probe(

cacheKey: string,

ownsKey: () => boolean,

repoPath: string,

remoteName: string,

connectionId: string | null | undefined,

localGitOptions: RemoteRefLocalGitOptions

): Promise<Ref | null> {

// Why: a probe abandoned as stale still runs, and its answer describes a repo

// state older than whatever the successor is about to store — or already has.

// It may still answer its own callers; it may not publish.

const publish = (value: Ref | null): void => {

if (ownsKey()) {

remember(cacheKey, value)

}

}

try {

const stdout = await readRemoteUrl(

{

repoPath,

connectionId,

...(localGitOptions.wslDistro ? { wslDistro: localGitOptions.wslDistro } : {}),

...(localGitOptions.admissionTier ? { admissionTier: localGitOptions.admissionTier } : {})

},

remoteName

)

// Why: null is an SSH repo this process cannot read, not an answer about the remote.

if (stdout === null) {

return null

}

const result = parseRemoteUrl(stdout)

publish(result)

return result

} catch (error) {

// Why: a probe killed on its deadline says nothing about the remote.

if (isTransientGitProbeError(error)) {

return null

}

publish(null)

return null

}

}

return {

async get(repoPath, remoteName, connectionId, localGitOptions = {}) {

const runtimeKey = connectionId || `local:${localGitOptions.wslDistro ?? 'host'}`

const cacheKey = `${runtimeKey}\0${repoPath}\0${remoteName}`

const cached = repoRefCache.get(cacheKey)

if (cached) {

if (cached.expiresAt > Date.now()) {

return cached.value

}

repoRefCache.delete(cacheKey)

}

// Why: every branch of a repo resolves its forge through this probe, so a

// poll of the worktree list arrives as a burst of identical lookups. One

// young probe answers all of them instead of spawning a `git` per branch.

return runCoalescedProbe(inFlight, cacheKey, (ownsKey) =>

probe(cacheKey, ownsKey, repoPath, remoteName, connectionId, localGitOptions)

)

},

clear() {

repoRefCache.clear()

inFlight.clear()

},

size() {

return repoRefCache.size

}

}

}