mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 02:47:34 +00:00
Retire repository proof when committed parent edges disappear
This commit is contained in:
+25
-20
@@ -1,5 +1,9 @@
|
||||
import { relativePathInsideRoot } from '../../../../../../shared/cross-platform-path'
|
||||
import { ExplorerRepositoryFrontierSupport } from './file-explorer-repository-frontier-support'
|
||||
import {
|
||||
ExplorerRepositoryProofEdges,
|
||||
sameRepositoryListingOwner
|
||||
} from './file-explorer-repository-proof-edges'
|
||||
import type { ExplorerRepositoryCandidate } from './file-explorer-repository-observer'
|
||||
import type { DirCache, FileExplorerOperationOwner } from './file-explorer-types'
|
||||
|
||||
@@ -16,25 +20,11 @@ type FrontierConsumer = {
|
||||
) => void
|
||||
invalidate: (path: string) => void
|
||||
resetProof: () => void
|
||||
branches: (path: string) => readonly string[]
|
||||
invalidateSubtree: (path: string) => void
|
||||
}
|
||||
|
||||
function sameOwner(
|
||||
a: FileExplorerOperationOwner | undefined,
|
||||
b: FileExplorerOperationOwner
|
||||
): boolean {
|
||||
return (
|
||||
a?.kind === b.kind &&
|
||||
(b.kind === 'ssh'
|
||||
? a.kind === 'ssh' && a.connectionId === b.connectionId
|
||||
: b.kind === 'runtime'
|
||||
? a.kind === 'runtime' &&
|
||||
a.environmentId === b.environmentId &&
|
||||
a.executionHostId === b.executionHostId
|
||||
: true)
|
||||
)
|
||||
}
|
||||
|
||||
/** Each reachable directory owns its direct contribution; hidden commits retain only path headers. */
|
||||
/** Each reachable directory owns its direct contribution; hidden structure retains only path headers. */
|
||||
export class ExplorerRepositoryFrontier {
|
||||
private current: Readonly<Record<string, DirCache>> = {}
|
||||
private consumed = this.current
|
||||
@@ -52,12 +42,20 @@ export class ExplorerRepositoryFrontier {
|
||||
private support = new ExplorerRepositoryFrontierSupport()
|
||||
private changes = new Map<string, ExplorerRepositoryCandidate | undefined>()
|
||||
private affected = new Set<string>()
|
||||
private proofEdges: ExplorerRepositoryProofEdges
|
||||
|
||||
constructor(
|
||||
private root: string,
|
||||
private owner: FileExplorerOperationOwner,
|
||||
private consumer: FrontierConsumer
|
||||
) {}
|
||||
) {
|
||||
this.proofEdges = new ExplorerRepositoryProofEdges(
|
||||
root,
|
||||
owner,
|
||||
consumer.branches,
|
||||
consumer.invalidateSubtree
|
||||
)
|
||||
}
|
||||
|
||||
setView(
|
||||
displayRoot: string | null,
|
||||
@@ -78,10 +76,12 @@ export class ExplorerRepositoryFrontier {
|
||||
this.current = cache
|
||||
if (reset) {
|
||||
this.reset = true
|
||||
this.proofEdges.clear()
|
||||
this.dirty.clear()
|
||||
this.consumer.resetProof()
|
||||
} else {
|
||||
for (const path of paths) {
|
||||
this.proofEdges.commit(path, cache[path])
|
||||
const relative = relativePathInsideRoot(this.root, path)
|
||||
const before = this.valid(previous[path]) ? previous[path] : undefined
|
||||
const after = this.valid(cache[path]) ? cache[path] : undefined
|
||||
@@ -167,6 +167,7 @@ export class ExplorerRepositoryFrontier {
|
||||
this.consumed = this.current
|
||||
this.consumedExpanded = this.expanded
|
||||
this.dirty.clear()
|
||||
this.proofEdges.clear()
|
||||
for (const path of this.support.changedRanges()) {
|
||||
this.affected.add(path)
|
||||
}
|
||||
@@ -178,7 +179,11 @@ export class ExplorerRepositoryFrontier {
|
||||
}
|
||||
|
||||
private valid(cache: DirCache | undefined): cache is DirCache {
|
||||
return !!cache && cache.error === undefined && sameOwner(cache.operationOwner, this.owner)
|
||||
return (
|
||||
!!cache &&
|
||||
cache.error === undefined &&
|
||||
sameRepositoryListingOwner(cache.operationOwner, this.owner)
|
||||
)
|
||||
}
|
||||
|
||||
private refreshCandidate(path: string): void {
|
||||
@@ -235,7 +240,7 @@ export class ExplorerRepositoryFrontier {
|
||||
if (
|
||||
child.outsideProject ||
|
||||
child.isSymlink ||
|
||||
!sameOwner(child.operationOwner, this.owner)
|
||||
!sameRepositoryListingOwner(child.operationOwner, this.owner)
|
||||
) {
|
||||
continue
|
||||
}
|
||||
|
||||
+3
-1
@@ -16,7 +16,9 @@ export function buildExplorerRepositoryFrontier(
|
||||
const frontier = new ExplorerRepositoryFrontier(root, owner, {
|
||||
apply: () => {},
|
||||
invalidate: () => {},
|
||||
resetProof: () => {}
|
||||
resetProof: () => {},
|
||||
branches: () => [],
|
||||
invalidateSubtree: () => {}
|
||||
})
|
||||
frontier.setView(displayRoot, expanded, hasRootGitSource)
|
||||
frontier.commit(dirCache, [])
|
||||
|
||||
+22
@@ -172,6 +172,28 @@ export class FileExplorerRepositoryObserver {
|
||||
this.discovery.invalidate(path)
|
||||
}
|
||||
|
||||
proofBranches(path: string): string[] {
|
||||
return [
|
||||
...new Set([...this.discovery.index.branches(path), ...this.sourceIndex.branches(path)])
|
||||
]
|
||||
}
|
||||
|
||||
invalidateProofSubtree(path: string): void {
|
||||
for (const candidate of this.discovery.index.descendants([path])) {
|
||||
this.discovery.invalidate(candidate)
|
||||
}
|
||||
for (const sourcePath of this.sourceIndex.descendants([path])) {
|
||||
const source = this.sources.get(sourcePath)!
|
||||
source.statusDirty = true
|
||||
source.proofRevision++
|
||||
source.proofRetryAt = -Infinity
|
||||
source.ignoredQueries.invalidate(this.visible)
|
||||
if (this.visible) {
|
||||
source.scheduler.signal()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
setDemand(paths: readonly string[] = this.demand, partition?: ExplorerRepositoryDemand): void {
|
||||
this.demand = paths
|
||||
updateExplorerRepositoryDemand(this.sources, paths, this.visible, () => this.emit(), partition)
|
||||
|
||||
+6
@@ -52,6 +52,12 @@ export class ExplorerRepositoryPathIndex {
|
||||
return this.find(path)?.member === true
|
||||
}
|
||||
|
||||
branches(path: string): string[] {
|
||||
return [...(this.find(path)?.children.keys() ?? [])].map((part) =>
|
||||
path ? `${path}/${part}` : part
|
||||
)
|
||||
}
|
||||
|
||||
set(paths: Iterable<string>): void {
|
||||
this.root = { member: false, children: new Map() }
|
||||
for (const path of paths) {
|
||||
|
||||
+85
@@ -0,0 +1,85 @@
|
||||
import { relativePathInsideRoot } from '../../../../../../shared/cross-platform-path'
|
||||
import type { DirCache, FileExplorerOperationOwner } from './file-explorer-types'
|
||||
|
||||
export function sameRepositoryListingOwner(
|
||||
a: FileExplorerOperationOwner | undefined,
|
||||
b: FileExplorerOperationOwner
|
||||
): boolean {
|
||||
return (
|
||||
a?.kind === b.kind &&
|
||||
(b.kind === 'ssh'
|
||||
? a.kind === 'ssh' && a.connectionId === b.connectionId
|
||||
: b.kind === 'runtime'
|
||||
? a.kind === 'runtime' &&
|
||||
a.environmentId === b.environmentId &&
|
||||
a.executionHostId === b.executionHostId
|
||||
: true)
|
||||
)
|
||||
}
|
||||
|
||||
/** Protected edges survive uncertain omissions, but never a proven identity break. */
|
||||
export class ExplorerRepositoryProofEdges {
|
||||
private parents = new Map<string, Set<string>>()
|
||||
|
||||
constructor(
|
||||
private root: string,
|
||||
private owner: FileExplorerOperationOwner,
|
||||
private branches: (path: string) => readonly string[],
|
||||
private invalidate: (path: string) => void
|
||||
) {}
|
||||
|
||||
commit(path: string, listing: DirCache | undefined): void {
|
||||
const relative = relativePathInsideRoot(this.root, path)
|
||||
if (relative === null) {
|
||||
return
|
||||
}
|
||||
let protectedEdges = this.parents.get(relative)
|
||||
if (!protectedEdges) {
|
||||
protectedEdges = new Set(this.branches(relative))
|
||||
if (!protectedEdges.size) {
|
||||
return
|
||||
}
|
||||
this.parents.set(relative, protectedEdges)
|
||||
}
|
||||
if (
|
||||
!protectedEdges.size ||
|
||||
!listing ||
|
||||
listing.error !== undefined ||
|
||||
!sameRepositoryListingOwner(listing.operationOwner, this.owner)
|
||||
) {
|
||||
return
|
||||
}
|
||||
const present = new Set<string>()
|
||||
if (!listing.outsideProject) {
|
||||
for (const child of listing.children) {
|
||||
const childPath = relativePathInsideRoot(this.root, child.path)
|
||||
if (childPath === null || !protectedEdges.has(childPath)) {
|
||||
continue
|
||||
}
|
||||
if (
|
||||
child.isDirectory &&
|
||||
!child.isSymlink &&
|
||||
!child.outsideProject &&
|
||||
sameRepositoryListingOwner(child.operationOwner, this.owner)
|
||||
) {
|
||||
present.add(childPath)
|
||||
} else {
|
||||
this.invalidate(childPath)
|
||||
protectedEdges.delete(childPath)
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!listing.more || listing.outsideProject) {
|
||||
for (const child of protectedEdges) {
|
||||
if (!present.has(child)) {
|
||||
this.invalidate(child)
|
||||
protectedEdges.delete(child)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
clear(): void {
|
||||
this.parents.clear()
|
||||
}
|
||||
}
|
||||
+26
-6
@@ -1,3 +1,4 @@
|
||||
import { ExplorerRepositoryFrontier } from './file-explorer-repository-frontier-owner'
|
||||
import { afterEach, expect, it, vi } from 'vitest'
|
||||
import type {
|
||||
GitRepositoryStatus,
|
||||
@@ -315,17 +316,36 @@ it('discards invalidated in-flight discovery proof while healthy siblings and la
|
||||
}
|
||||
)
|
||||
const cache = discoveryCache(101)
|
||||
applyDiscoveryCache(observer, cache)
|
||||
const frontier = new ExplorerRepositoryFrontier(
|
||||
'/w',
|
||||
{ kind: 'local' },
|
||||
{
|
||||
apply: (changes, affected, retains) => observer.updateFrontier(changes, affected, retains),
|
||||
invalidate: (path) => observer.invalidateCandidate(path),
|
||||
resetProof: () => observer.invalidate(),
|
||||
branches: (path) => observer.proofBranches(path),
|
||||
invalidateSubtree: (path) => observer.invalidateProofSubtree(path)
|
||||
}
|
||||
)
|
||||
frontier.setView('/w', new Set(), true)
|
||||
frontier.commit(cache, [], true)
|
||||
frontier.setVisible(true)
|
||||
observer.setVisible(true)
|
||||
try {
|
||||
await vi.advanceTimersByTimeAsync(1000)
|
||||
expect(probes).toHaveLength(1)
|
||||
expect(probes[0]).toHaveLength(100)
|
||||
observer.invalidateChanges([{ path: 'd1/.git', kind: 'update', directory: false }])
|
||||
applyDiscoveryCache(observer, {
|
||||
...cache,
|
||||
'/w/unrelated': { operationOwner: { kind: 'local' }, children: [] }
|
||||
})
|
||||
frontier.commit(
|
||||
{
|
||||
...cache,
|
||||
'/w': {
|
||||
...cache['/w'],
|
||||
children: cache['/w'].children.filter((child) => child.relativePath !== 'd1')
|
||||
}
|
||||
},
|
||||
['/w']
|
||||
)
|
||||
frontier.commit(cache, ['/w'])
|
||||
release(probes[0].map((path) => ({ path, kind: 'repository' })))
|
||||
await vi.advanceTimersByTimeAsync(0)
|
||||
expect(probes).toHaveLength(2)
|
||||
|
||||
+160
@@ -495,3 +495,163 @@ it('keeps unknown discovery backoff across repeated unreadable cache updates', a
|
||||
expect(probes).toEqual([['folder'], ['folder']])
|
||||
fixture.unmount()
|
||||
})
|
||||
|
||||
it.each([1000, 10000])(
|
||||
'retires only discontinued hidden parent edges among %i unrelated directories',
|
||||
async (count) => {
|
||||
vi.useFakeTimers()
|
||||
supports.mockResolvedValue(true)
|
||||
const repositories = new Set<string>()
|
||||
const probes: string[][] = []
|
||||
read.mockImplementation(async (_route, request: GitRepositoryStatusRequest) => {
|
||||
if (request.repositoryIntent === 'probe') {
|
||||
probes.push(request.repositoryPaths!)
|
||||
}
|
||||
return {
|
||||
repositoryStatuses: request.repositoryPaths!.map((path) => ({
|
||||
path,
|
||||
kind: repositories.has(path) ? 'repository' : 'absent',
|
||||
...(repositories.has(path) && request.repositoryIntent === 'status'
|
||||
? { status: { entries: [], conflictOperation: 'unknown' } }
|
||||
: {})
|
||||
}))
|
||||
}
|
||||
})
|
||||
let parentRows = 0
|
||||
let unrelatedRows = 0
|
||||
let unrelatedMetadata = 0
|
||||
const child = (name: string): TreeNode => ({
|
||||
...node(`p/${name}`, true),
|
||||
get outsideProject() {
|
||||
parentRows++
|
||||
return undefined
|
||||
}
|
||||
})
|
||||
const initialParent: DirCache = {
|
||||
operationOwner: owner,
|
||||
repositoryMarker: false,
|
||||
children: [child('d'), child('stable')]
|
||||
}
|
||||
const cache: Record<string, DirCache> = {
|
||||
'/w': {
|
||||
operationOwner: owner,
|
||||
children: [
|
||||
node('p', true),
|
||||
...Array.from({ length: count }, (_, index) => ({
|
||||
...node(`peer${index}`, true),
|
||||
get outsideProject() {
|
||||
unrelatedRows++
|
||||
return undefined
|
||||
}
|
||||
}))
|
||||
]
|
||||
},
|
||||
'/w/p': initialParent
|
||||
}
|
||||
for (let index = 0; index < count; index++) {
|
||||
cache[`/w/peer${index}`] = {
|
||||
operationOwner: owner,
|
||||
children: [],
|
||||
get repositoryMarker() {
|
||||
unrelatedMetadata++
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
const store = new FileExplorerDirectoryCache()
|
||||
store.update(() => ({
|
||||
dirCache: cache,
|
||||
sourceWorkspaceId: 'folder:w',
|
||||
reset: true,
|
||||
changedPaths: []
|
||||
}))
|
||||
const expanded = new Set(['/w/p'])
|
||||
const fixture = renderHook(
|
||||
({ visible }) =>
|
||||
useFileExplorerRepositories(
|
||||
'folder:w',
|
||||
'/w',
|
||||
'/w',
|
||||
{ dirCacheStore: store },
|
||||
expanded,
|
||||
visible,
|
||||
true
|
||||
),
|
||||
{ initialProps: { visible: true } }
|
||||
)
|
||||
await act(() => vi.advanceTimersByTimeAsync(1000))
|
||||
expect(probes.flat().sort()).toEqual(['p/d', 'p/stable'])
|
||||
const commit = (listing: DirCache): void => {
|
||||
act(() =>
|
||||
store.update((previous) => ({
|
||||
dirCache: { ...previous, '/w/p': listing },
|
||||
changedPaths: ['/w/p']
|
||||
}))
|
||||
)
|
||||
}
|
||||
const partial = { ...initialParent, children: [child('stable')], more: true }
|
||||
const failed = { ...initialParent, children: [], error: 'unreadable' }
|
||||
fixture.rerender({ visible: false })
|
||||
probes.length = 0
|
||||
parentRows = unrelatedRows = unrelatedMetadata = 0
|
||||
commit(failed)
|
||||
commit(partial)
|
||||
commit(initialParent)
|
||||
expect(parentRows).toBe(3)
|
||||
expect(probes).toEqual([])
|
||||
fixture.rerender({ visible: true })
|
||||
await act(() => vi.advanceTimersByTimeAsync(4000))
|
||||
expect(probes.flat()).toEqual(['p'])
|
||||
|
||||
fixture.rerender({ visible: false })
|
||||
probes.length = 0
|
||||
parentRows = 0
|
||||
// Transient unadmitted edges do not create proof history or retry obligations.
|
||||
for (let index = 0; index < 20; index++) {
|
||||
commit({
|
||||
...initialParent,
|
||||
children: [...initialParent.children, child(`transient${index}`)]
|
||||
})
|
||||
commit(initialParent)
|
||||
}
|
||||
expect(parentRows).toBe(80)
|
||||
commit(failed)
|
||||
commit(partial)
|
||||
commit({ ...initialParent, children: [child('stable')] })
|
||||
const freshParent = { ...initialParent, children: [child('d'), child('stable')] }
|
||||
commit(freshParent)
|
||||
expect(parentRows).toBe(83)
|
||||
repositories.add('p/d')
|
||||
await act(() => vi.advanceTimersByTimeAsync(600_000))
|
||||
expect(probes).toEqual([])
|
||||
expect(parentRows).toBe(83)
|
||||
expect(unrelatedRows).toBe(0)
|
||||
expect(unrelatedMetadata).toBe(0)
|
||||
fixture.rerender({ visible: true })
|
||||
await act(() => vi.advanceTimersByTimeAsync(4000))
|
||||
expect(probes.flat()).toEqual(['p/d'])
|
||||
expect(fixture.result.current.sources.map((source) => source.path)).toEqual(['p/d'])
|
||||
expect(parentRows).toBe(85)
|
||||
|
||||
// Even a return to the identical parent object cannot restore stable's old proof.
|
||||
fixture.rerender({ visible: false })
|
||||
probes.length = 0
|
||||
parentRows = 0
|
||||
commit({ ...freshParent, children: [child('d')] })
|
||||
commit(freshParent)
|
||||
repositories.add('p/stable')
|
||||
expect(parentRows).toBe(2)
|
||||
expect(probes).toEqual([])
|
||||
fixture.rerender({ visible: true })
|
||||
await act(() => vi.advanceTimersByTimeAsync(4000))
|
||||
expect(probes.flat().sort()).toEqual(['p', 'p/stable'])
|
||||
expect(fixture.result.current.sources.map((source) => source.path).sort()).toEqual([
|
||||
'p/d',
|
||||
'p/stable'
|
||||
])
|
||||
expect(unrelatedRows).toBe(0)
|
||||
expect(unrelatedMetadata).toBe(0)
|
||||
fixture.unmount()
|
||||
expect(vi.getTimerCount()).toBe(0)
|
||||
}
|
||||
)
|
||||
|
||||
+3
-1
@@ -93,7 +93,9 @@ export function useFileExplorerRepositories(
|
||||
const model = new ExplorerRepositoryFrontier(root, JSON.parse(ownerKey), {
|
||||
apply: (changes, affected, retains) => instance.updateFrontier(changes, affected, retains),
|
||||
invalidate: (path) => instance.invalidateCandidate(path),
|
||||
resetProof: () => instance.invalidate()
|
||||
resetProof: () => instance.invalidate(),
|
||||
branches: (path) => instance.proofBranches(path),
|
||||
invalidateSubtree: (path) => instance.invalidateProofSubtree(path)
|
||||
})
|
||||
frontier.current = model
|
||||
applyView(model)
|
||||
|
||||
Reference in New Issue
Block a user