fix(settings): preserve RAM retries and find matching Java on PATH

This commit is contained in:
Codex
2026-09-09 18:57:21 +03:00
parent 3f3be65a3f
commit cd5c675637
4 changed files with 130 additions and 14 deletions
+57 -6
View File
@@ -60,18 +60,28 @@ pub fn ensure_java(
required_major: u8, required_major: u8,
on_progress: &ProgressCallback, on_progress: &ProgressCallback,
) -> Result<JavaInstallation, EnsureJavaError> { ) -> Result<JavaInstallation, EnsureJavaError> {
if let Some(installation) = detect() { if let Some(installation) = find_matching(candidates(), required_major, check_candidate) {
if installation.major == required_major { on_progress(1, 1);
on_progress(1, 1); return Ok(installation);
return Ok(installation);
}
} }
let executable = runtime::ensure_runtime(client, runtime_root, required_major, on_progress) let executable = runtime::ensure_runtime(client, runtime_root, required_major, on_progress)
.map_err(EnsureJavaError::Provisioning)?; .map_err(EnsureJavaError::Provisioning)?;
check_candidate(executable.clone()) check_candidate(executable.clone())
.filter(|installation| installation.major == required_major)
.ok_or(EnsureJavaError::ProvisionedButUnrecognised(executable)) .ok_or(EnsureJavaError::ProvisionedButUnrecognised(executable))
} }
fn find_matching(
candidates: impl IntoIterator<Item = PathBuf>,
required_major: u8,
mut inspect: impl FnMut(PathBuf) -> Option<JavaInstallation>,
) -> Option<JavaInstallation> {
candidates
.into_iter()
.filter_map(&mut inspect)
.find(|installation| installation.major == required_major)
}
fn candidates() -> Vec<PathBuf> { fn candidates() -> Vec<PathBuf> {
let executable = if cfg!(target_os = "windows") { let executable = if cfg!(target_os = "windows") {
"java.exe" "java.exe"
@@ -127,7 +137,48 @@ fn parse_major(version: &str) -> Option<u8> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{parse_major, parse_version}; use super::*;
#[test]
fn matching_path_runtime_is_not_hidden_by_wrong_java_home() {
let candidates = ["JAVA_HOME", "PATH"].map(PathBuf::from);
let found = find_matching(candidates, 21, |path| {
let major = if path == Path::new("JAVA_HOME") {
17
} else {
21
};
Some(JavaInstallation {
executable: path.display().to_string(),
major,
version: major.to_string(),
})
})
.unwrap();
assert_eq!(found.executable, "PATH");
}
#[test]
fn matching_home_remains_preferred_and_unusable_candidates_are_skipped() {
let found = find_matching(["broken", "home", "path"].map(PathBuf::from), 21, |path| {
assert_ne!(path, Path::new("path"), "must stop at matching JAVA_HOME");
(path != Path::new("broken")).then(|| JavaInstallation {
executable: path.display().to_string(),
major: 21,
version: "21".into(),
})
})
.unwrap();
assert_eq!(found.executable, "home");
assert!(find_matching([PathBuf::from("newer")], 21, |path| Some(
JavaInstallation {
executable: path.display().to_string(),
major: 25,
version: "25".into()
}
))
.is_none());
}
#[test] #[test]
fn parses_modern_java_version() { fn parses_modern_java_version() {
+12 -7
View File
@@ -1,5 +1,5 @@
import { useEffect, useRef, useState } from 'react' import { useEffect, useRef, useState } from 'react'
import { createSerialQueue, errorMessage } from '../services/async' import { createSaveIntent, createSerialQueue, errorMessage } from '../services/async'
import { isNative, native } from '../services/native' import { isNative, native } from '../services/native'
import { defaultSettings } from '../state/settings' import { defaultSettings } from '../state/settings'
import type { LauncherSettings } from '../types/launcher' import type { LauncherSettings } from '../types/launcher'
@@ -12,7 +12,7 @@ export function useSettings() {
const [loadAttempt, setLoadAttempt] = useState(0) const [loadAttempt, setLoadAttempt] = useState(0)
const current = useRef(settings) const current = useRef(settings)
const durable = useRef(settings) const durable = useRef(settings)
const revision = useRef(0) const intent = useRef(createSaveIntent<LauncherSettings>())
const queue = useRef(createSerialQueue()) const queue = useRef(createSerialQueue())
useEffect(() => { useEffect(() => {
@@ -38,21 +38,23 @@ export function useSettings() {
setSettings(next) setSettings(next)
setError(null) setError(null)
if (!isNative()) return if (!isNative()) return
const requestRevision = ++revision.current const request = intent.current.begin(next)
setSaving(true) setSaving(true)
void queue.current.enqueue(() => native.saveSettings(next)).then((value) => { void queue.current.enqueue(() => native.saveSettings(next)).then((value) => {
durable.current = value durable.current = value
if (revision.current === requestRevision) { intent.current.succeeded(request)
if (intent.current.isLatest(request)) {
current.current = value current.current = value
setSettings(value) setSettings(value)
} }
}).catch((reason: unknown) => { }).catch((reason: unknown) => {
if (revision.current !== requestRevision) return if (!intent.current.isLatest(request)) return
intent.current.failed(request)
current.current = durable.current current.current = durable.current
setSettings(durable.current) setSettings(durable.current)
setError(errorMessage(reason, 'Не удалось сохранить настройки')) setError(errorMessage(reason, 'Не удалось сохранить настройки'))
}).finally(() => { }).finally(() => {
if (revision.current === requestRevision) setSaving(false) if (intent.current.isLatest(request)) setSaving(false)
}) })
} }
@@ -61,7 +63,10 @@ export function useSettings() {
updateRam: (memoryGb: number) => save({ memoryMb: memoryGb * 1024 }), updateRam: (memoryGb: number) => save({ memoryMb: memoryGb * 1024 }),
retry: () => { retry: () => {
if (!loaded) setLoadAttempt((attempt) => attempt + 1) if (!loaded) setLoadAttempt((attempt) => attempt + 1)
else save({}) else {
const failed = intent.current.retryValue()
if (failed) save(failed)
}
}, },
} }
} }
+48 -1
View File
@@ -1,6 +1,6 @@
import { deepStrictEqual, equal, rejects } from 'node:assert/strict' import { deepStrictEqual, equal, rejects } from 'node:assert/strict'
import { test } from 'node:test' import { test } from 'node:test'
import { createRequestScope, createSerialQueue, createSubscription, errorMessage, singleFlight } from './async.ts' import { createSaveIntent, createRequestScope, createSerialQueue, createSubscription, errorMessage, singleFlight } from './async.ts'
function deferred<T>() { function deferred<T>() {
let resolve!: (value: T) => void let resolve!: (value: T) => void
@@ -111,3 +111,50 @@ test('logout or a newer challenge invalidates a delayed account/link response',
equal(belongsToNewChallenge(), true) equal(belongsToNewChallenge(), true)
equal(belongsToAccount(), false) equal(belongsToAccount(), false)
}) })
test('RAM retry retains the failed 8 GB choice after rollback to durable 6 GB', async () => {
const intent = createSaveIntent<{ memoryMb: number }>()
const queue = createSerialQueue()
let current = { memoryMb: 6 * 1024 }
let durable = current
const writes: number[] = []
const save = async (next: typeof current, fail: boolean) => {
current = next
const request = intent.begin(next)
try {
const value = await queue.enqueue(async () => {
writes.push(next.memoryMb)
if (fail) throw new Error('disk full')
return next
})
durable = value
intent.succeeded(request)
} catch {
intent.failed(request)
current = durable
}
}
await save({ memoryMb: 8 * 1024 }, true)
equal(current.memoryMb, 6 * 1024)
await save(intent.retryValue()!, false)
deepStrictEqual(writes, [8 * 1024, 8 * 1024])
equal(durable.memoryMb, 8 * 1024)
equal(intent.retryValue(), null)
})
test('older settings failure cannot replace a newer choice or remain retryable after success', () => {
const intent = createSaveIntent<number>()
const older = intent.begin(8)
const newer = intent.begin(10)
intent.failed(older)
equal(intent.retryValue(), null)
intent.failed(newer)
equal(intent.retryValue(), 10)
const latest = intent.begin(12)
intent.succeeded(older)
intent.failed(latest)
equal(intent.retryValue(), 12)
intent.succeeded(latest)
equal(intent.retryValue(), null)
})
+13
View File
@@ -44,6 +44,19 @@ export function createSerialQueue() {
} }
} }
/** Retain the latest failed user choice even when UI rolls back to disk state. */
export function createSaveIntent<T>() {
let revision = 0
let failed: T | null = null
return {
begin: (value: T) => { failed = null; return { revision: ++revision, value } },
isLatest: (request: { revision: number }) => request.revision === revision,
succeeded: (request: { revision: number }) => { if (request.revision === revision) failed = null },
failed: (request: { revision: number; value: T }) => { if (request.revision === revision) failed = request.value },
retryValue: () => failed,
}
}
/** Handles unmount before asynchronous native listener registration finishes. */ /** Handles unmount before asynchronous native listener registration finishes. */
export function createSubscription( export function createSubscription(
registrations: readonly Promise<() => void>[], registrations: readonly Promise<() => void>[],