Versions & release notes<\/summary>/)
assert.match(SoftwarePage.template, /data\.updater\.lastCheckedAt/)
for (const progress of [{stage: "idle", detail: "", percent: null}, {stage: null, detail: null, percent: null}, {stage: "unknown", detail: "", percent: null}]) {
@@ -514,7 +472,7 @@ for (const stage of ["complete", "error"]) {
assert.equal(softwareProgress(state, {progress}).active, false)
assert.equal(softwareProgress(state, {progress}).percent, null)
}
-assert.equal(softwareProgress({...updater, state: "finalizing update..."}, {progress: {stage: "finalizing", detail: null, percent: null}}).label, "Finalizing update")
+assert.equal(softwareProgress({...updater, state: "finalizing update..."}, {progress: {stage: "finalizing", detail: null, percent: null}}).label, "Preparing update")
const lightweight = fixture(false)
lightweight.feed.start()
@@ -528,6 +486,11 @@ await lightweight.reply(1, snapshot({ operations: { ...operations, history } }))
assert.deepEqual(lightweight.states.at(-1).data.operations.history, history)
lightweight.feed.stop()
+const versionRefreshActions = []
+await SoftwarePage.methods.loadVersions.call({ actionDisabled: false, draftBranch: 'Dom',
+ operations: { selectedTarget: 'Dom' }, feed: { action: (...args) => versionRefreshActions.push(args) } })
+assert.deepEqual(versionRefreshActions, [['versions', 'Dom']], 'version refresh must use the metadata-only operation')
+
const directBranch = fixture()
directBranch.feed.start()
await directBranch.reply(0,snapshot({operations:{...operations,availableBranches:['Dom','beta'],canFastUpdate:true}}))
@@ -544,7 +507,7 @@ directBranch.feed.stop()
// A visit checks immediately, without interrupting an update already in progress.
for (const [canCheck, pending, state, expected] of [
[true, false, 'idle', ['check']], [false, false, 'idle', []],
- [true, true, 'idle', []], [true, false, 'downloading...', []],
+ [true, true, 'idle', []], [true, false, 'downloading...', ['check']],
]) {
const actions = []
const view = { mode: 'local', initialChecking: true, operations: { canCheck }, pending,
@@ -556,7 +519,7 @@ for (const [canCheck, pending, state, expected] of [
const updateView = { ...SoftwarePage.data(), data: snapshot(), operations: { ...operations },
requestMessage: SoftwarePage.methods.requestMessage }
-for (const key of ['pending', 'reportedProgress', 'updateProgress', 'updateAvailable', 'osUpdateRequired', 'updateBanner', 'repositoryUrl', 'commitUrl', 'commitsUrl']) {
+for (const key of ['pending', 'reportedProgress', 'metadataProgress', 'backgroundProgress', 'updateProgress', 'updateAvailable', 'osUpdateRequired', 'updateBanner', 'repositoryUrl', 'commitUrl', 'commitsUrl']) {
Object.defineProperty(updateView, key, { get: () => SoftwarePage.computed[key].call(updateView) })
}
assert.equal(updateView.updateProgress.label, 'Checking for updates')
@@ -576,7 +539,7 @@ updateView.data = snapshot({ updater: { ...updater, targetChangeFound: false } }
updateView.operations.request = request('check', 'complete')
assert.equal(updateView.updateBanner.message, 'No Update Available')
updateView.operations.request = request('check')
-assert.equal(updateView.updateProgress.label, 'Checking for updates')
+assert.equal(updateView.updateProgress.label, 'Checking for new versions')
assert.equal(updateView.updateBanner, null)
updateView.operations.request = request('check', 'failed', null, 'Network unavailable')
assert.equal(updateView.updateProgress, null)
@@ -652,7 +615,7 @@ for (const action of ['update', 'fast', 'rollback', 'install', 'version']) {
const f = fixture(true, baseline => restarts.push(baseline))
f.feed.start()
await f.reply(0, snapshot({ operations: { ...operations, canFastUpdate: true, canRollback: true, canInstall: true,
- history: { installed: [], downloaded: [], currentReleaseNotes: null, downloadedReleaseNotes: null,
+ history: { installed: [], downloaded: [{ hash: 'b'.repeat(40), date: '', subject: '' }], currentReleaseNotes: null, downloadedReleaseNotes: null,
recent: { branch: 'Dom', head: installed.commit, entries: [{ hash: 'b'.repeat(40), date: '', subject: '' }] } } } }))
f.feed.action(action, 'Dom', { expectedCommit: installed.commit, selectedCommit: 'b'.repeat(40) })
assert.equal(f.requests.length, 2)
@@ -697,3 +660,146 @@ for (const [status, payload, unauthorized] of [
f.feed.stop()
}
console.log('Software status and tunnel-envelope regressions passed')
+
+// Metadata checks remain separate from a background finalization and its real progress.
+updateView.error = ''
+updateView.operations = { ...operations, reason: 'Updater is busy', request: request('versions'),
+ progress: { stage: 'finalizing', detail: 'Copying update files: 44/100 (44%)', percent: 44, background: true } }
+updateView.data = snapshot({ updater: { ...updater, state: 'finalizing update...',
+ fast: { stage: 'finalizing', check: { state: 'checking', detail: 'Fetching version metadata...' } } } })
+assert.equal(updateView.updateProgress.label, 'Checking for new versions')
+assert.equal(updateView.backgroundProgress.percent, 44)
+assert.match(updateView.backgroundProgress.detail, /44\/100/)
+assert.equal(SoftwarePage.computed.metadataActionDisabled.call(updateView), false)
+updateView.data.updater.fast.check = { state: 'complete' }
+updateView.operations.request = request('versions', 'complete')
+assert.equal(updateView.updateProgress, null)
+assert.equal(updateView.backgroundProgress.percent, 44)
+
+// Clicking Check immediately replaces the previous Refresh versions result, before its POST returns.
+const nextCheck = fixture()
+nextCheck.feed.start()
+await nextCheck.reply(0, snapshot({ operations: { ...operations, request: request('versions', 'complete') } }))
+nextCheck.feed.action('check')
+assert.equal(nextCheck.states.at(-1).submittingAction, 'check')
+updateView.operations = { ...operations, request: request('versions', 'complete') }
+updateView.data = snapshot()
+updateView.busy = true
+updateView.submittingAction = nextCheck.states.at(-1).submittingAction
+assert.equal(updateView.updateProgress.label, 'Checking for new versions')
+assert.equal(updateView.updateBanner, null)
+await nextCheck.reply(1, snapshot({ operations: { ...operations, request: request('check') } }))
+assert.equal(nextCheck.states.at(-1).submittingAction, null)
+nextCheck.feed.stop()
+
+updateView.busy = false
+updateView.submittingAction = null
+updateView.operations = { ...operations, request: null }
+updateView.draftBranch = 'Dom'
+updateView.data = snapshot({ updater: { ...updater, finalizedUpdateReady: true } })
+assert.deepEqual(updateView.updateBanner, { tone: 'success', message: 'Downloaded · Ready to install' })
+
+// Downloading a selected version pins it without entering restart recovery.
+const selectedDownload = fixture()
+const selectedHash = 'b'.repeat(40)
+const selectionHistory = { installed: [], downloaded: [], currentReleaseNotes: null, downloadedReleaseNotes: null,
+ recent: { branch: 'beta', head: selectedHash, entries: [{hash:selectedHash,date:'',subject:'Beta build'}] } }
+selectedDownload.feed.start()
+await selectedDownload.reply(0, snapshot({operations:{...operations, canFastUpdate:true, history:selectionHistory}}))
+selectedDownload.feed.action('download-version', 'beta', {expectedCommit:installed.commit,selectedCommit:selectedHash})
+assert.deepEqual(JSON.parse(selectedDownload.requests[1].options.body), {action:'download-version',branch:'beta',expectedCommit:installed.commit,selectedCommit:selectedHash})
+assert.equal(selectedDownload.feed.installBaseline, null)
+await selectedDownload.reply(1, snapshot({operations:{...operations,request:request('download-version','pending','beta')}}))
+assert.equal(selectedDownload.feed.installBaseline, null)
+selectedDownload.feed.stop()
+
+const previousSelection = page('Dom',['Dom','beta'])
+previousSelection.operations.history = {previous:{hash:selectedHash,date:'',subject:'Previous',branch:'beta'}}
+previousSelection.syncDraftBranch = SoftwarePage.methods.syncDraftBranch.bind(previousSelection)
+await SoftwarePage.methods.selectPreviousVersion.call(previousSelection)
+assert.equal(previousSelection.draftBranch, 'beta')
+assert.equal(previousSelection.version, selectedHash)
+assert.deepEqual(previousSelection.calls, [], 'selecting a saved previous version must not refresh metadata')
+assert.equal(previousSelection.dialog,null,'selecting previous must not install it')
+
+// A finished metadata refresh must leave the actual update status visible.
+updateView.error = ''
+updateView.busy = false
+updateView.submittingAction = null
+updateView.initialChecking = false
+updateView.draftBranch = 'Dom'
+updateView.operations = { ...operations, request: request('versions', 'complete') }
+updateView.data = snapshot({ updater: { ...updater, finalizedUpdateReady: true } })
+assert.equal(updateView.updateBanner.message, 'Downloaded · Ready to install')
+updateView.data.updater.finalizedUpdateReady = false
+assert.equal(updateView.updateBanner.message, 'Update Available')
+updateView.data.updater.targetChangeFound = false
+assert.equal(updateView.updateBanner.message, 'No Update Available')
+assert.equal(SoftwarePage.methods.requestMessage(request('versions', 'complete')), '')
+
+const branchLayout = page()
+branchLayout.changeBranch = SoftwarePage.methods.changeBranch.bind(branchLayout)
+SoftwarePage.methods.syncDraftBranch.call(branchLayout, 'Dom')
+assert.equal(branchLayout.primaryChoice, 'Dom')
+branchLayout.primaryChoice = 'other:'
+await SoftwarePage.methods.onPrimaryBranchChange.call(branchLayout)
+assert.equal(branchLayout.draftBranch, '')
+assert.deepEqual(branchLayout.calls, [], 'opening Other does not refresh metadata without a branch')
+assert.deepEqual(branchLayout.otherBranches.map(branch => branch.name), ['beta'])
+branchLayout.draftBranch = 'beta'
+await branchLayout.changeBranch()
+assert.deepEqual(branchLayout.calls, ['beta'])
+branchLayout.primaryChoice = 'StarPilot'
+await SoftwarePage.methods.onPrimaryBranchChange.call(branchLayout)
+assert.equal(branchLayout.draftBranch, 'StarPilot')
+assert.deepEqual(branchLayout.calls, ['beta', 'StarPilot'])
+assert.equal(previousSelection.primaryChoice, 'other:', 'previous selection synchronizes both selectors without refreshing')
+
+assert.doesNotMatch(SoftwarePage.template, /Refresh versions/)
+assert.match(SoftwarePage.template, /@click="loadVersions">Refresh/ )
+assert.match(SoftwarePage.template, /feed.action\('check'\)">Check for updates/)
+
+assert.match(SoftwarePage.template, /GalaxySelect show-description v-model="primaryChoice"/)
+assert.doesNotMatch(SoftwarePage.template, /{toggleSettings=args}}},true)
+assert.deepEqual(toggleSettings,[true,'0 0 * * *','UTC'],'toggle preserves the saved timezone')
diff --git a/openpilot/starpilot/galaxy/tests/test_version_timeline.mjs b/openpilot/starpilot/galaxy/tests/test_version_timeline.mjs
new file mode 100644
index 0000000000..14ac7e6fd6
--- /dev/null
+++ b/openpilot/starpilot/galaxy/tests/test_version_timeline.mjs
@@ -0,0 +1,173 @@
+import assert from 'node:assert/strict'
+import { compile } from '../web/vendor/vue/vue.esm-browser.js'
+import { SoftwarePage } from '../web/js/software-status.js'
+
+const rows = Array.from({ length: 20 }, (_, i) => ({ hash: (i + 1).toString(16).padStart(40, '0'),
+ date: new Date(Date.UTC(2026, 9, 29 - i)).toISOString(), subject: `Version ${20 - i}` }))
+const vm = { ...SoftwarePage.data(), initialChecking: false, mode: 'local',
+ draftBranch: 'Dom', data: { installed: { branch: 'Dom', commit: rows[15].hash },
+ updater: { state: 'idle', targetBranch: 'Dom', finalizedUpdateReady: true }, operations: {
+ parked: true, canFastUpdate: true, canInstall: true, selectedTarget: 'Dom', availableBranches: ['Dom'],
+ history: { installed: rows.slice(15), downloaded: rows.slice(3), currentReleaseNotes: 'Installed notes',
+ downloadedReleaseNotes: 'Downloaded notes', downloadedCommits: [rows[3].hash, rows[4].hash], recent: { branch: 'Dom', head: rows[0].hash, entries: rows } } } } }
+for (const [name, getter] of Object.entries(SoftwarePage.computed))
+ Object.defineProperty(vm, name, { get: () => getter.call(vm) })
+for (const [name, method] of Object.entries(SoftwarePage.methods)) vm[name] = method.bind(vm)
+
+assert.equal(vm.shortCommit('1234567890abcdef'), '12345678')
+assert.equal(vm.versionEntries.length, 20, 'merge overlapping sources without duplicates')
+assert.equal(vm.visibleVersions.length, 4)
+assert.equal(vm.visibleVersions[0].hash, rows[0].hash, 'keep newest at the top')
+assert.equal(vm.visibleVersions.at(-2).hash, rows[15].hash, 'keep installed visible')
+assert.equal(vm.visibleVersions.at(-1).hash, rows[16].hash, 'show one older version')
+assert.equal(vm.hiddenNewerCount, 13)
+assert.equal(vm.hiddenOlderCount, 3)
+assert.equal(vm.selectedVersion.hash, rows[15].hash)
+assert.equal(vm.selectedVersionAction, 'No changes selected')
+assert.equal(vm.canInstallSelection, false)
+assert.equal(vm.selectedReleaseNotes, 'Installed notes')
+
+vm.version = rows[3].hash
+assert.equal(vm.selectedVersionAction, 'Install selected version')
+assert.equal(vm.selectedReleaseNotes, 'Downloaded notes')
+assert.equal(vm.canInstallSelection, true)
+vm.askSelectedVersion()
+assert.deepEqual([vm.dialog.action, vm.dialog.selectedCommit, vm.dialog.expectedCommit],
+ ['install', rows[3].hash, rows[15].hash])
+
+vm.version = rows[0].hash
+assert.equal(vm.selectedVersionAction, 'Download and install selected version')
+assert.equal(vm.canInstallSelection, true)
+assert.equal(vm.selectedReleaseNotes, null)
+vm.askSelectedVersion()
+assert.equal(vm.dialog.action, 'version')
+assert.equal(vm.dialog.selectedCommit, rows[0].hash)
+
+vm.data.updater.finalizedUpdateReady = false
+vm.version = rows[3].hash
+assert.equal(vm.selectedVersionAction, 'Install selected version', 'complete cached files remain downloaded when staging is not ready')
+vm.version = rows[4].hash
+assert.equal(vm.selectedVersionAction, 'Install selected version', 'cached commits need not be the prepared head')
+vm.askSelectedVersion()
+assert.equal(vm.dialog.action, 'version', 'cached versions still pass through pinned validation')
+vm.newerVersionLimit += 10
+assert.equal(vm.hiddenNewerCount, 3)
+assert.equal(vm.visibleVersions.length, 14, 'newer paging must not reveal older rows')
+assert.equal(vm.hiddenOlderCount, 3)
+vm.newerVersionLimit += 10
+vm.olderVersionLimit += 10
+assert.equal(vm.visibleVersions.length, 20)
+assert.equal(vm.hiddenOlderCount, 0)
+vm.newerVersionLimit = 2
+vm.olderVersionLimit = 1
+assert.equal(vm.visibleVersions.length, 4)
+
+// Separate gaps remain exact across multiple pages of ten.
+const longRows = Array.from({length: 60}, (_, i) => ({hash:(i + 100).toString(16).padStart(40, '0'),date:'',subject:`Build ${i}`}))
+vm.data.operations.history.recent.entries = longRows
+vm.data.operations.history.installed = longRows.slice(35)
+vm.data.installed.commit = longRows[35].hash
+assert.equal(vm.hiddenNewerCount, 33)
+assert.equal(vm.hiddenOlderCount, 23)
+for (const remaining of [23, 13, 3, 0]) {
+ const before = vm.visibleVersions.length
+ const count = Math.min(10, vm.hiddenNewerCount)
+ vm.newerVersionLimit += 10
+ assert.equal(vm.visibleVersions.length - before, count)
+ assert.equal(vm.hiddenNewerCount, remaining)
+ assert.equal(vm.hiddenOlderCount, 23)
+}
+for (const remaining of [13, 3, 0]) {
+ const before = vm.visibleVersions.length
+ const count = Math.min(10, vm.hiddenOlderCount)
+ vm.olderVersionLimit += 10
+ assert.equal(vm.visibleVersions.length - before, count)
+ assert.equal(vm.hiddenOlderCount, remaining)
+}
+vm.data.operations.history.recent.entries = rows
+vm.data.operations.history.installed = rows.slice(15)
+vm.data.installed.commit = rows[15].hash
+vm.data.operations.history.recent.entries = rows.slice(0, 10)
+vm.version = rows[19].hash
+assert.equal(vm.canInstallSelection, true, 'older installed history remains selectable outside the recent list')
+vm.data.operations.history.recent.entries = rows
+vm.newerVersionLimit = 2
+vm.olderVersionLimit = 1
+vm.data.installed.commit = 'f'.repeat(40)
+vm.version = ''
+assert.equal(vm.visibleVersions.at(-1).hash, 'f'.repeat(40), 'retain installed outside fetched history on its own branch')
+assert.equal(vm.selectedVersionAction, 'No changes selected')
+vm.busy = true
+vm.version = rows[0].hash
+assert.equal(vm.canInstallSelection, false)
+vm.busy = false
+vm.data.operations.parked = false
+assert.equal(vm.canInstallSelection, false)
+
+compile(SoftwarePage.template, { decodeEntities: value => value })
+console.log('Version timeline selection, limits, expansion, and template passed')
+
+// Pin the actual previous installed commit with independent gaps above and below it.
+vm.data.operations.parked = true
+vm.data.operations.canRollback = true
+vm.data.installed.commit = longRows[15].hash
+vm.data.operations.history.recent.entries = longRows
+vm.data.operations.history.installed = longRows.slice(15)
+vm.data.operations.history.previous = longRows[40]
+vm.newerVersionLimit = 2
+vm.olderVersionLimit = 1
+vm.collapsedOlderLimit = 0
+vm.version = ''
+assert.deepEqual(vm.visibleVersions.map(row => row.hash), [...longRows.slice(0, 2), longRows[15], longRows[40]].map(row => row.hash))
+assert.equal(vm.hiddenNewerCount, 13)
+assert.equal(vm.hiddenCollapsedOlderCount, 24)
+assert.equal(vm.hiddenOlderCount, 19)
+for (const remaining of [14, 4, 0]) {
+ const before = vm.visibleVersions.length
+ const count = Math.min(10, vm.hiddenCollapsedOlderCount)
+ vm.collapsedOlderLimit += count
+ assert.equal(vm.visibleVersions.length - before, count)
+ assert.equal(vm.hiddenCollapsedOlderCount, remaining)
+ assert.equal(vm.hiddenOlderCount, 19)
+}
+vm.olderVersionLimit += 10
+assert.equal(vm.hiddenOlderCount, 9)
+assert.equal(vm.visibleVersions.at(-1).hash, longRows[50].hash)
+vm.version = longRows[40].hash
+assert.equal(vm.selectedVersionAction, 'Install selected version')
+assert.equal(vm.canInstallSelection, true)
+vm.askSelectedVersion()
+assert.equal(vm.dialog.action, 'rollback')
+vm.data.operations.history.previous = longRows[0]
+assert.equal(vm.visibleVersions.filter(row => row.hash === longRows[0].hash).length, 1, 'previous version may be newer after a rollback')
+
+// Diverged branches contain neither installed history nor a previous-version anchor.
+vm.data.operations.history.previous = { ...longRows[40], branch:'Dom' }
+vm.draftBranch = 'StarPilot'
+vm.data.operations.history.recent = {branch:'StarPilot',head:rows[0].hash,entries:rows.slice(0,10)}
+vm.newerVersionLimit = 2
+vm.version = ''
+assert.equal(vm.hasInstalledVersion, false)
+assert.equal(vm.listedPreviousVersion, null)
+assert.deepEqual(vm.visibleVersions.map(row => row.hash), rows.slice(0,2).map(row => row.hash))
+assert.equal(vm.hiddenNewerCount,8)
+vm.newerVersionLimit += 10
+assert.equal(vm.visibleVersions.length,10,'diverged history remains pageable without installed anchors')
+vm.syncDraftBranch(vm.previousVersion.branch)
+vm.version = vm.previousVersion.hash
+assert.equal(vm.listedPreviousVersion.hash,vm.previousVersion.hash,'explicit local previous selection needs no metadata refresh')
+
+// Glow only while a different selectable commit is waiting to be installed.
+assert.equal(vm.selectionNeedsInstall, true)
+vm.data.updater.state = 'updating...'
+assert.equal(vm.selectionNeedsInstall, false)
+vm.data.updater.state = 'idle'
+vm.feed = {installBaseline:{}}
+assert.equal(vm.selectionNeedsInstall, false)
+vm.feed.installBaseline = null
+assert.equal(vm.selectionNeedsInstall, true)
+vm.busy = true
+assert.equal(vm.selectionNeedsInstall, false)
+vm.busy = false
+vm.version = vm.data.installed.commit
+assert.equal(vm.selectionNeedsInstall, false)
diff --git a/openpilot/starpilot/galaxy/web/css/galaxy.css b/openpilot/starpilot/galaxy/web/css/galaxy.css
index e11a4fd8c0..6eb1491c66 100644
--- a/openpilot/starpilot/galaxy/web/css/galaxy.css
+++ b/openpilot/starpilot/galaxy/web/css/galaxy.css
@@ -1228,16 +1228,37 @@ button.gx-chip:hover {
.gx-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}
.gx-release-notes{white-space:pre-wrap;font:inherit;line-height:1.6;overflow-wrap:anywhere}
-.gx-build-history { display: grid; gap: var(--sp-3); max-height: 320px; overflow-y: auto; }
-.gx-build-history li { min-width: 0; padding: var(--sp-3); border: 1px solid var(--glass-border); border-radius: var(--radius-sm); overflow-wrap: anywhere; }
-.gx-build-history strong { display: block; color: var(--on-surface); }
-.gx-build-history small { display: block; margin-top: var(--sp-1); color: var(--on-surface-variant); }
.gx-software-summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 180px), 1fr)); gap: var(--sp-3); margin: 0; }
.gx-software-summary dt { font-size: var(--fs-sm); color: var(--on-surface-variant); }
.gx-software-summary dd { margin: var(--sp-1) 0 0; font-weight: var(--fw-bold); overflow-wrap: anywhere; }
.gx-software-options { border-top: 1px solid var(--glass-border); }
.gx-software-options > .gx-stack { padding-top: var(--sp-4); }
.gx-software-card details{padding:12px 0}.gx-software-card summary{cursor:pointer;font-weight:600}
+.gx-version-action--pending { animation: gx-version-heartbeat 1.8s ease-in-out infinite; }
+@keyframes gx-version-heartbeat {
+ 0%, 45%, 100% { box-shadow: 0 0 0 0 transparent; }
+ 12%, 32% { box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 25%, transparent), 0 0 20px color-mix(in srgb, var(--primary) 55%, transparent); }
+ 22% { box-shadow: 0 0 0 1px color-mix(in srgb, var(--primary) 15%, transparent), 0 0 10px color-mix(in srgb, var(--primary) 30%, transparent); }
+}
+@media (prefers-reduced-motion: reduce) {
+ .gx-version-action--pending { animation: none; box-shadow: 0 0 0 2px color-mix(in srgb, var(--primary) 35%, transparent); }
+}
+.gx-restart-cron { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)) minmax(180px, 2fr); gap: var(--sp-3); }
+@media (max-width: 800px) { .gx-restart-cron { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
+.gx-version-scroll { max-height: min(760px, 65dvh); overflow-y: auto; overscroll-behavior: contain; scrollbar-gutter: stable; padding: 3px; }
+.gx-version-list { display: grid; gap: var(--sp-2); list-style: none; margin: 0; padding: 0; }
+.gx-version-row { display: flex; align-items: center; gap: var(--sp-3); min-height: 64px; padding: var(--sp-3); border: 2px solid var(--outline-variant); border-radius: var(--radius-sm); cursor: pointer; }
+.gx-version-row:hover { background: color-mix(in srgb, var(--primary) 6%, transparent); }
+.gx-version-row--installed { background: color-mix(in srgb, var(--primary) 9%, transparent); }
+.gx-version-row--selected { border-color: var(--primary); box-shadow: 0 0 0 1px var(--primary); }
+.gx-version-row:focus-within { outline: 2px solid var(--primary); outline-offset: 2px; }
+.gx-version-row input { flex: 0 0 auto; width: 20px; height: 20px; accent-color: var(--primary); }
+.gx-version-content { min-width: 0; display: grid; gap: var(--sp-1); overflow-wrap: anywhere; }
+.gx-version-content small { color: var(--on-surface-variant); }
+.gx-version-meta .gx-version-badge { display: inline-block; margin-inline-start: var(--sp-2); white-space: nowrap; }
+.gx-version-badge { padding: 2px 8px; border-radius: 999px; font-size: var(--fs-sm); color: var(--on-surface-variant); background: var(--surface-container-high); }
+.gx-version-badge--installed, .gx-version-badge--downloaded { color: var(--primary); background: color-mix(in srgb, var(--primary) 14%, transparent); }
+.gx-version-gap { display: flex; flex-direction: column; align-items: center; gap: var(--sp-2); padding: var(--sp-2); }
.gx-navigation-map { position:relative; border-radius:12px; overflow:hidden; background:#20303b; margin-bottom:16px; }
.gx-navigation-map canvas { display:block; width:100%; height:360px; touch-action:none; cursor:grab; }
diff --git a/openpilot/starpilot/galaxy/web/js/drive-state.js b/openpilot/starpilot/galaxy/web/js/drive-state.js
index e6e14ea86a..e0330b1e82 100644
--- a/openpilot/starpilot/galaxy/web/js/drive-state.js
+++ b/openpilot/starpilot/galaxy/web/js/drive-state.js
@@ -7,9 +7,10 @@ export const validDriveState = (value) => !!value && ["auto", "offroad", "onroad
export const DriveStatePanel = {
components: { GxNotice },
- props: { offroadOnly: { type: Boolean, default: false } },
- data: () => ({ state: null, error: "", busy: false }),
+ props: { offroadOnly: { type: Boolean, default: false }, lockout: { type: Boolean, default: true } },
+ data: () => ({ state: null, error: "", statusError: "", busy: false }),
computed: {
+ visible() { return !this.offroadOnly || this.lockout || this.state?.mode === 'offroad' || !!this.error },
pending() { return this.state?.mode !== "auto" && this.state?.effective !== this.state?.mode },
},
mounted() {
@@ -31,13 +32,21 @@ export const DriveStatePanel = {
const response = await fetch("./api/drive-state/status", { credentials: "same-origin", cache: "no-store", signal: this.controller.signal })
const value = await response.json()
if (!response.ok || !validDriveState(value)) throw new Error(value.error || "Drive state unavailable")
- if (this.active && generation === this.generation) { this.state = value; this.error = "" }
- } catch (error) { if (this.active && generation === this.generation) { this.state = null; this.error = "Drive state unavailable" } }
+ if (this.active && generation === this.generation) { this.state = value; this.statusError = "" }
+ } catch (error) { if (this.active && generation === this.generation) { this.state = null; this.statusError = "Drive state unavailable" } }
finally { clearTimeout(deadline); if (generation === this.generation) this.loading = false }
},
+ async toggleOffroad(event) {
+ const input = event.target
+ const mode = input.checked ? 'offroad' : 'auto'
+ input.checked = this.state?.mode === 'offroad'
+ await this.change(mode)
+ input.checked = this.state?.mode === 'offroad'
+ },
async change(mode) {
if (this.busy || !this.state?.available) return
if (!["onroad", "offroad", "auto"].includes(mode)) return
+ this.error = ""
const feedback = beginSave()
const revision = this.state.revision
this.busy = true
@@ -57,16 +66,15 @@ export const DriveStatePanel = {
finally { clearTimeout(deadline); this.busy = false; if (this.active && generation === this.generation) this.load() }
},
},
- template: `
-
{{ error }}
+ template: `
+
{{ error || statusError }}
The drive-state manager is unavailable. Reconnect to check again.
Waiting for the device to switch {{ state.mode }}…
-
Device: {{ state?.effective === "onroad" ? "Onroad" : state?.effective === "offroad" ? "Offroad" : "Checking…" }}
+
Device: {{ state?.effective === "onroad" ? "Onroad" : state?.effective === "offroad" ? "Offroad" : "Checking…" }}
Auto follows the car. Force Onroad starts driving services at any time. Return to Auto restores normal operation.
-
Force Offroad Force device offroad Park the vehicle and disengage controls to enable. Turn off to restore automatic drive state.
-
Park the vehicle and disengage controls to enable. Turn off to restore automatic drive state.
+ @change="toggleOffroad" />
item.value === this.selected)?.description || "" },
current() { return this.modelValue !== undefined ? this.modelValue : this.value },
buttonId() { return this.$attrs.id || this.uid },
nativeAttrs() {
@@ -129,7 +130,7 @@ export const GalaxySelect = {
- {{ label }} {{ label }} {{ selectedDescription }}
- Check for updates
+ Check for updates
Update
+
+
Background download · {{ backgroundProgress.label }} {{ Math.round(backgroundProgress.percent) }}%
+
{{ backgroundProgress.detail }}
+
Checked {{ reported(data.updater.lastCheckedAt) }}
· Downloaded {{ reported(data.updater.lastFetchAt) }}
+
+ {{ shortCommit(operations.preparedCommit) }} {{ shortCommit(operations.preparedCommit) }} is ready for install. Click Update when ready.
+ Auto install will run at {{ reported(operations.nextRestartAt) }} while offroad.
+
The download preference could not be read. Choose a setting while parked to repair it.
-
Advanced options
-
Branch
-
- Choose a branch
+ Install preferences are unreadable. Save the schedule to repair them.
+ Advanced options
+ Branch
+
Stable — StarPilot
Development — Dom
Other branches…
-
- {{ primaryBranchHelp }}
-
-
Other branches
-
Additional branches from this installation's repository.
-
+
+ Other branches
+
{{ otherBranches.length ? 'Select another branch' : 'No other branches available' }}
- {{ branch.name }}{{ branch.current ? ' (current)' : '' }}{{ !branch.listed && !branch.current ? ' (unavailable)' : '' }}
+ {{ branch.name }}
+
+ {{ selectedVersionAction }}
+ Refresh
+ Download only
+ Select previous version
- This branch is not in the updater's available list and cannot be selected yet.
- No branch list is available yet. Check for updates to refresh it.
- Update installs {{ draftBranch }} and restarts the device.
-
-
Save target
-
Download only
-
Previous version
+
-
Download only prepares an update without restarting. Previous version restores your last installed build.
-
Versions & release notes
-
- {{ source.label }}
-
-
-
- Choose a version
- {{ versionLabel(entry) }} Load versions
- Install version
-
Up to 20 compatible versions of {{ draftBranch }}.
-
-
{{ entry.subject.trim() || shortCommit(entry.hash) }} {{ reported(entry.date) }} · {{ shortCommit(entry.hash) }} {{ operations.history ? 'No versions saved.' : 'Reading history…' }}
-
{{ operations.history.currentReleaseNotes }}
-
{{ operations.history.downloadedReleaseNotes }}
+
Release notes {{ selectedReleaseNotes }}
+
Release notes are not available for this version.
+
StarPilot 7.0 ', 'Version
'):
+ path.write_text(empty)
+ assert release_notes(params, path.name) is None
+ path.write_text('# Version\n\n* Fixed updates')
+ assert release_notes(params, path.name) == '# Version\n\n* Fixed updates'
diff --git a/openpilot/starpilot/software/tests/test_preferences.py b/openpilot/starpilot/software/tests/test_preferences.py
index 11f14aae29..6a4380691d 100644
--- a/openpilot/starpilot/software/tests/test_preferences.py
+++ b/openpilot/starpilot/software/tests/test_preferences.py
@@ -12,10 +12,8 @@ def test_default_saved_and_invalid_values_preserve_manual_requests(tmp_path, raw
if raw is not None:
Path(params.get_param_path(AUTOMATIC_DOWNLOADS)).write_bytes(raw)
assert automatic_downloads(params) is expected
- assert download_permitted(params, manual=False, check_only=False) is (expected is True)
- assert download_permitted(params, manual=True, check_only=False)
- assert not download_permitted(params, manual=False, check_only=True)
- assert not download_permitted(params, manual=True, check_only=True)
+ assert download_permitted(params, manual=False) is (expected is True)
+ assert download_permitted(params, manual=True)
def test_nonregular_and_symlink_preferences_do_not_enable_automatic_downloads(tmp_path):
diff --git a/openpilot/starpilot/software/tests/test_update_control.py b/openpilot/starpilot/software/tests/test_update_control.py
index 1353dd2a51..84d4fb75a4 100644
--- a/openpilot/starpilot/software/tests/test_update_control.py
+++ b/openpilot/starpilot/software/tests/test_update_control.py
@@ -52,11 +52,22 @@ class UpdaterControlTests(unittest.TestCase):
with self.assertRaises(update_control.UpdaterControlError):
update_control._command('fast', 'Dom', expected, selected)
+ def test_download_version_pins_both_commits_without_becoming_an_install(self):
+ expected, selected = 'a' * 40, 'b' * 40
+ command = update_control._command('download-version', 'Dom', expected, selected)
+ self.assertEqual(update_control._parse(command + b'\n'), ('download-version', 'Dom', expected, selected))
+ self.assertLessEqual(len(update_control._command('download-version', 'x' * 128, expected, selected)) + 1,
+ update_control.MAX_COMMAND)
+ with self.assertRaises(update_control.UpdaterControlError):
+ update_control._command('download-version', 'Dom', expected, 'HEAD')
+
def test_server_delivers_fast_identity_and_legacy_callback_shape(self):
for raw, expected in ((b'update Dom ' + b'a' * 40 + b'\n', mock.call('update', branch='Dom', commit='a' * 40)),
(b'fast Dom ' + b'a' * 40 + b'\n', mock.call('fast', branch='Dom', commit='a' * 40)),
(b'version Dom ' + b'a' * 40 + b' ' + b'b' * 40 + b'\n',
mock.call('version', branch='Dom', commit='a' * 40, selected_commit='b' * 40)),
+ (b'download-version Dom ' + b'a' * 40 + b' ' + b'b' * 40 + b'\n',
+ mock.call('download-version', branch='Dom', commit='a' * 40, selected_commit='b' * 40)),
(b'versions Dom ' + b'a' * 40 + b'\n', mock.call('versions', branch='Dom', commit='a' * 40)),
(b'check\n', mock.call('check')), (b'download\n', mock.call('download'))):
with self.subTest(raw=raw):
@@ -88,6 +99,16 @@ class UpdaterControlTests(unittest.TestCase):
self.assertEqual(request, updated.UserRequest.ROLLBACK)
self.assertEqual(target, ('Dom', 'a' * 40))
+ def test_check_requests_background_work_but_versions_only_requests_metadata(self):
+ from openpilot.system.updated import updated
+ callback = mock.Mock()
+ helper = updated.WaitTimeHelper.__new__(updated.WaitTimeHelper)
+ helper.metadata = callback
+ helper._control_request('check')
+ callback.assert_called_with(branch=None, commit=None, download_after=True)
+ helper._control_request('versions', branch='Dom', commit='a' * 40)
+ callback.assert_called_with(branch='Dom', commit='a' * 40, download_after=False)
+
def test_same_process_control_and_stale_identity(self):
actions = []
accepted = threading.Event()
diff --git a/openpilot/starpilot/software/tests/test_update_process.py b/openpilot/starpilot/software/tests/test_update_process.py
index 8a734c79b2..c63f80ddbe 100644
--- a/openpilot/starpilot/software/tests/test_update_process.py
+++ b/openpilot/starpilot/software/tests/test_update_process.py
@@ -5,8 +5,9 @@ import sys
import tempfile
import time
import unittest
+from unittest.mock import patch
-from openpilot.starpilot.software.fast_update import run
+from openpilot.starpilot.software.fast_update import FastUpdateError, run
class TestUpdateProcess(unittest.TestCase):
@@ -56,6 +57,39 @@ finally:
self.assertEqual(error.exception.output, b'locked\n')
self.assertFalse((self.directory / 'shallow.lock').exists())
+ def test_progress_burst_is_coalesced_without_losing_output(self):
+ command = self.command("for i in range(1000): print(f'Receiving objects: {i}\\r', end='')\n")
+ progress = []
+ result = run(command, self.directory, progress.append)
+ self.assertIn('Receiving objects: 500\r', result)
+ self.assertEqual(progress[0], 'Receiving objects: 0')
+ self.assertEqual(progress[-1], 'Receiving objects: 999')
+ self.assertLess(len(progress), 20)
+
+ def test_phone_uplink_interrupts_implicit_downloads(self):
+ command = self.command("from pathlib import Path\nimport time\nPath('started').touch()\ntime.sleep(60)\n")
+ with patch('openpilot.starpilot.software.fast_update.phone_uplink_active',
+ side_effect=lambda: (self.directory / 'started').exists()):
+ with self.assertRaisesRegex(FastUpdateError, 'software download stopped'):
+ run(command, self.directory, download=True, timeout=5)
+
+ def test_pending_progress_is_delivered_while_command_is_quiet(self):
+ command = self.command("""import time
+from pathlib import Path
+print('Receiving objects: 1%\\rReceiving objects: 99%', flush=True)
+deadline = time.monotonic() + 2
+while not Path('progress_received').exists() and time.monotonic() < deadline:
+ time.sleep(0.01)
+print('received while running' if Path('progress_received').exists() else 'progress stalled')
+""")
+
+ def progress(detail):
+ if detail == 'Receiving objects: 99%':
+ (self.directory / 'progress_received').touch()
+
+ result = run(command, self.directory, progress)
+ self.assertIn('received while running', result)
+
def test_stubborn_command_is_killed(self):
command = self.command("""import os
import signal
diff --git a/openpilot/starpilot/software/update_control.py b/openpilot/starpilot/software/update_control.py
index 9a411a5b1e..4dd3074d7a 100644
--- a/openpilot/starpilot/software/update_control.py
+++ b/openpilot/starpilot/software/update_control.py
@@ -82,9 +82,9 @@ def available(pid: int, start: int) -> bool:
def _command(action: str, branch=None, commit=None, selected_commit=None) -> bytes:
- if action == 'version' and type(selected_commit) is str and _COMMIT.fullmatch(selected_commit):
+ if action in ('version', 'download-version') and type(selected_commit) is str and _COMMIT.fullmatch(selected_commit):
base = _command('fast', branch, commit).decode('ascii').split(' ', 1)[1]
- return f'version {base} {selected_commit}'.encode('ascii')
+ return f'{action} {base} {selected_commit}'.encode('ascii')
if selected_commit is not None:
raise UpdaterControlError('Invalid updater version target')
if action in ('check', 'download') and branch is None and commit is None:
@@ -100,7 +100,7 @@ def _parse(command: bytes):
return command[:-1].decode('ascii'), None, None
try:
parts = command[:-1].decode('ascii').split(' ')
- if len(parts) == 4 and parts[0] == 'version' and command.endswith(b'\n'):
+ if len(parts) == 4 and parts[0] in ('version', 'download-version') and command.endswith(b'\n'):
action, branch, commit, selected = parts
if _command(action, branch, commit, selected) + b'\n' == command:
return action, branch, commit, selected
@@ -160,7 +160,7 @@ class UpdaterControlServer:
else:
parsed = _parse(command)
action, branch, commit = parsed[:3]
- if action == 'version':
+ if action in ('version', 'download-version'):
self.request(action, branch=branch, commit=commit, selected_commit=parsed[3])
elif action in ('update', 'fast', 'rollback', 'versions'):
self.request(action, branch=branch, commit=commit)
diff --git a/openpilot/starpilot/tests/test_external_preferences_reset.py b/openpilot/starpilot/tests/test_external_preferences_reset.py
index 60ffe7895b..b64d523f00 100644
--- a/openpilot/starpilot/tests/test_external_preferences_reset.py
+++ b/openpilot/starpilot/tests/test_external_preferences_reset.py
@@ -177,3 +177,14 @@ class TestExternalPreferencesReset(unittest.TestCase):
if __name__ == '__main__':
unittest.main()
+
+
+def test_fresh_preferences_disable_scheduled_automatic_installation(tmp_path):
+ from openpilot.starpilot.software.auto_install import InstallSettings
+ settings = InstallSettings(tmp_path / 'software' / 'auto-install')
+ value = settings.read()
+ assert value is not None
+ settings.save(True, '0 0 * * *', value['revision'], lambda: True)
+ assert reset.reset_external_preferences(tmp_path, tmp_path / 'models') == ()
+ value = settings.read()
+ assert value is not None and not value['enabled']
diff --git a/openpilot/starpilot/ui/runtime_snapshot.py b/openpilot/starpilot/ui/runtime_snapshot.py
index 1cd82bc5cc..ed186ae219 100644
--- a/openpilot/starpilot/ui/runtime_snapshot.py
+++ b/openpilot/starpilot/ui/runtime_snapshot.py
@@ -801,6 +801,10 @@ class RuntimeSnapshotAdapter:
offroad=confirmed_offroad,
available_actions=frozenset(device_actions))
updater_state = _text(params, "UpdaterState")
+ fast = params.get('UpdaterFastState')
+ fast = fast if isinstance(fast, dict) else {}
+ checking_metadata = fast.get('check', {}).get('state') == 'checking'
+ background = fast.get('background') and updater_state in ('downloading...', 'finalizing update...')
available = _flag(params, "UpdaterFetchAvailable")
status = "updater status unavailable" if not updater_state else updater_state if updater_state != "idle" else (
"update available" if available else "up to date, last checked " + ("previously" if _text(params, "LastUpdateTime") else "never"))
@@ -810,6 +814,11 @@ class RuntimeSnapshotAdapter:
if updater_state == "idle":
software_actions.update((SoftwareRequest.FAST_UPDATE, SoftwareRequest.ROLLBACK))
software_actions.add(SoftwareRequest.DOWNLOAD_UPDATE if available else SoftwareRequest.CHECK_FOR_UPDATES)
+ elif background and not checking_metadata:
+ software_actions.add(SoftwareRequest.CHECK_FOR_UPDATES)
+ if checking_metadata:
+ software_actions.discard(SoftwareRequest.CHECK_FOR_UPDATES)
+ software_actions.discard(SoftwareRequest.DOWNLOAD_UPDATE)
if not _flag(params, "IsTestedBranch") and _text(params, "UpdaterAvailableBranches"):
software_actions.add(SoftwareRequest.OPEN_BRANCH_CHOOSER)
software = SoftwareState(current_version=_text(params, "UpdaterCurrentDescription"),
diff --git a/openpilot/starpilot/ui/tests/test_runtime_snapshot.py b/openpilot/starpilot/ui/tests/test_runtime_snapshot.py
index 11df3dcf3f..cef1dc6e96 100644
--- a/openpilot/starpilot/ui/tests/test_runtime_snapshot.py
+++ b/openpilot/starpilot/ui/tests/test_runtime_snapshot.py
@@ -423,6 +423,18 @@ class TestRuntimeSnapshot(unittest.TestCase):
self.assertEqual(settings.software, first.software)
self.assertEqual(adapter.build(ShellMode.ONROAD, now_ns=NOW + 1_000_000_002).software, first.software)
+ def test_background_finalization_allows_metadata_check(self):
+ from openpilot.starpilot.ui.software_state import SoftwareRequest
+ ui = ui_fake()
+ ui.params.values['UpdaterState'] = 'finalizing update...'
+ ui.params.values['UpdaterFastState'] = {'background': True}
+ with patch.object(RuntimeSnapshotAdapter, '_parked', return_value=True):
+ state = RuntimeSnapshotAdapter(ui).build(ShellMode.SETTINGS, now_ns=NOW).software
+ self.assertIn(SoftwareRequest.CHECK_FOR_UPDATES, state.available_actions)
+ ui.params.values['UpdaterFastState']['check'] = {'state': 'checking'}
+ state = RuntimeSnapshotAdapter(ui).build(ShellMode.SETTINGS, now_ns=NOW).software
+ self.assertNotIn(SoftwareRequest.CHECK_FOR_UPDATES, state.available_actions)
+
def test_customization_uses_existing_refresh_and_invalidation(self):
adapter = RuntimeSnapshotAdapter(ui_fake())
first = default_document()
diff --git a/openpilot/system/updated/tests/test_vendored_update.py b/openpilot/system/updated/tests/test_vendored_update.py
index 4715312584..057643ceb9 100644
--- a/openpilot/system/updated/tests/test_vendored_update.py
+++ b/openpilot/system/updated/tests/test_vendored_update.py
@@ -12,6 +12,8 @@ import shutil
import subprocess
import sys
import tempfile
+import threading
+import time
import unittest
from pathlib import Path
from types import ModuleType
@@ -19,6 +21,7 @@ from unittest.mock import Mock, patch
from openpilot.common.vendor_manifest import DEPENDENCIES
+from openpilot.starpilot.software.auto_install import InstallSettings
BRANCH = "test-vendored"
@@ -30,6 +33,9 @@ class MemoryParams:
def get(self, key):
return self.values.get(key)
+ def get_bool(self, key):
+ return bool(self.values.get(key))
+
def put(self, key, value, **kwargs):
self.values[key] = value
@@ -100,14 +106,16 @@ class TestVendoredUpdate(unittest.TestCase):
self.updated = load_updater()
self.updated.OVERLAY_MERGED = str(self.merged)
+ self.updated.METADATA_ROOT = self.root / 'metadata.git'
self.updated.FINALIZED = str(self.finalized)
self.updated.BASEDIR = str(self.merged)
self.updated.set_consistent_flag = self.set_consistent_flag
self.updated.handle_agnos_update = Mock()
+ self.updated.init_overlay = Mock()
self.commands = []
real_run = self.updated.run
- def bounded_run(command, cwd=None):
+ def bounded_run(command, cwd=None, **kwargs):
if cwd is None:
raise AssertionError("Every updater command must name its isolated working directory")
self.assertTrue(Path(cwd).resolve().is_relative_to(self.root.resolve()))
@@ -115,10 +123,11 @@ class TestVendoredUpdate(unittest.TestCase):
self.commands.append(command)
if command in (["git", "gc"], ["git", "lfs", "prune"]):
return ""
- return real_run(command, cwd)
+ return real_run(command, cwd, **kwargs)
self.updated.run = bounded_run
- self.updater = self.updated.Updater()
+ self.updater = self.updated.Updater(install_settings=InstallSettings(self.root / 'install-settings'))
+ self.addCleanup(self.updater.close)
@staticmethod
def git(repo, *args):
@@ -166,10 +175,89 @@ class TestVendoredUpdate(unittest.TestCase):
self.updater.fast_update(BRANCH, self.initial_commit)
normal.assert_not_called() # Explicit fast/rollback/version operations keep their contract.
+ @patch('openpilot.starpilot.drive_state.evidence.PhysicalSource', return_value=Mock(update_ready=Mock(return_value=True)))
+ def test_download_selected_version_stages_exact_commit_without_installing(self, _physical):
+ installed = self.root / 'installed'
+ self.git(self.root, 'clone', '--no-local', str(self.merged), str(installed))
+ self.updated.BASEDIR = str(installed)
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
+ (self.source / 'version.txt').write_text('selected')
+ selected = self.commit_source('Selected version')
+ (self.source / 'version.txt').write_text('newest')
+ latest = self.commit_source('Newer version')
+ with patch.object(self.updater, 'set_params') as publish:
+ self.assertEqual(self.updater.fast_update(BRANCH, self.initial_commit, selected, download_only=True), 'downloaded')
+ publish.assert_called_once_with(True, 0, None)
+ self.assertEqual(self.git(installed, 'rev-parse', 'HEAD'), self.initial_commit)
+ self.assertEqual(self.git(self.finalized, 'rev-parse', 'HEAD'), selected)
+ self.assertEqual(self.git(self.finalized, 'rev-parse', 'refs/starpilot/previous'), self.initial_commit)
+ self.assertEqual(self.updater.branches[BRANCH], latest)
+ self.assertTrue(self.updater.update_ready)
+ self.assertFalse(self.updater.latest_update_ready)
+ self.assertFalse(self.updater.params.get_bool('DoReboot'))
+
+ @patch('openpilot.starpilot.drive_state.evidence.PhysicalSource', return_value=Mock(update_ready=Mock(return_value=True)))
+ def test_download_selected_version_rejects_changed_source_and_unlisted_target(self, _physical):
+ for expected, selected in (('f' * 40, self.initial_commit), (self.initial_commit, 'f' * 40)):
+ with self.subTest(expected=expected), self.assertRaises(self.updated.FastUpdateError):
+ self.updater.fast_update(BRANCH, expected, selected, download_only=True)
+ self.updated.init_overlay.assert_not_called()
+ self.assertEqual(self.git(self.merged, 'rev-parse', 'HEAD'), self.initial_commit)
+ self.assertFalse(self.updater.params.get_bool('DoReboot'))
+
+ def test_metadata_refresh_does_not_wake_background_but_check_does(self):
+ (self.source / 'new.txt').write_text('available')
+ self.commit_source('New update')
+ self.updater.wake_automatic = Mock()
+ with patch.object(self.updated, 'download_permitted', return_value=True):
+ self.updater.request_check(branch=BRANCH)
+ worker = self.updater._check_thread
+ if worker is not None:
+ worker.join(timeout=5)
+ self.updater.wake_automatic.assert_not_called()
+ self.updated.init_overlay.assert_not_called()
+ self.updater.request_check(branch=BRANCH, download_after=True)
+ worker = self.updater._check_thread
+ if worker is not None:
+ worker.join(timeout=5)
+ self.updater.wake_automatic.assert_called_once_with()
+
+ def test_scheduled_install_requires_clock_idle_and_fresh_offroad_evidence(self):
+ installed = self.root / 'installed'
+ self.git(self.root, 'clone', '--no-local', str(self.merged), str(installed))
+ self.updated.BASEDIR = str(installed)
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
+ (self.source / 'scheduled.txt').write_text('prepared')
+ self.commit_source('Prepared update for scheduling')
+ self.assertTrue(self.updater.fetch_update())
+ self.updater.params.put('UpdaterState', 'idle')
+ self.updater.params.put_bool('IsOffroad', True)
+ settings = self.updater.install_settings
+ current = settings.read()
+ assert current is not None
+ settings.save(True, '* * * * *', current['revision'], lambda: True)
+ physical = Mock(update_ready=Mock(return_value=True))
+ with patch('openpilot.starpilot.drive_state.evidence.PhysicalSource', return_value=physical), \
+ patch.object(self.updated, 'system_time_valid', return_value=False):
+ self.assertFalse(self.updater.maybe_install())
+ with patch('openpilot.starpilot.drive_state.evidence.PhysicalSource', return_value=physical), \
+ patch.object(self.updated, 'system_time_valid', return_value=True):
+ self.assertFalse(self.updater.maybe_install(lambda: False))
+ self.updater.params.put_bool('IsOffroad', False)
+ self.assertFalse(self.updater.maybe_install())
+ self.assertFalse(self.updater.params.get_bool('DoReboot'))
+ physical.update_ready.assert_not_called()
+ self.updater.params.put_bool('IsOffroad', True)
+ self.assertTrue(self.updater.maybe_install())
+ self.assertTrue(self.updater.params.get_bool('DoReboot'))
+ self.assertEqual(self.git(installed, 'rev-parse', 'HEAD'), self.initial_commit)
+ self.assertEqual(physical.update_ready.call_count, 2)
+
def test_normal_fallback_stages_flashes_and_requests_reboot_with_fresh_parked_state(self):
installed = self.root / "installed"
self.git(self.root, "clone", "--no-local", str(self.merged), str(installed))
self.updated.BASEDIR = str(installed)
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
(self.source / "panda/README.md").write_text("New native revision")
target = self.commit_source("Full update")
self.updated.AGNOS = True
@@ -187,6 +275,7 @@ class TestVendoredUpdate(unittest.TestCase):
installed = self.root / "installed"
self.git(self.root, "clone", "--no-local", str(self.merged), str(installed))
self.updated.BASEDIR = str(installed)
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
(self.source / "panda/README.md").write_text("New native revision")
self.commit_source("Full update")
parked = iter((True, False))
@@ -215,6 +304,7 @@ class TestVendoredUpdate(unittest.TestCase):
self.assertEqual(self.git(self.merged, "rev-parse", "HEAD"), target)
self.assertEqual(self.git(self.finalized, "rev-parse", "HEAD"), target)
self.assertEqual((self.finalized / "panda" / "README.md").read_text(), "Updated ordinary tracked source\n")
+ self.assertEqual(self.git(self.finalized, "rev-parse", f"refs/starpilot/recent/{BRANCH}"), target)
self.assertTrue((self.finalized / ".overlay_consistent").is_file())
for name in DEPENDENCIES:
self.assertFalse((self.finalized / name / ".git").exists())
@@ -223,6 +313,176 @@ class TestVendoredUpdate(unittest.TestCase):
self.assertEqual(self.git(self.merged, "config", "fetch.recurseSubmodules"), "false")
self.updated.handle_agnos_update.assert_not_called()
+ def test_filtered_fetch_preserves_history_without_obsolete_artifact_contents(self):
+ self.git(self.source, 'config', 'uploadpack.allowFilter', 'true')
+ self.git(self.source, 'config', 'uploadpack.allowReachableSHA1InWant', 'true')
+ self.git(self.merged, 'remote', 'set-url', 'origin', self.source.as_uri())
+ artifact = self.source / 'artifact.bin'
+ artifact.write_bytes(os.urandom(128 * 1024))
+ middle = self.commit_source('Superseded large artifact')
+ obsolete_blob = self.git(self.source, 'rev-parse', 'HEAD:artifact.bin')
+ artifact.write_bytes(os.urandom(128 * 1024))
+ target = self.commit_source('Chosen large artifact')
+ target_blob = self.git(self.source, 'rev-parse', 'HEAD:artifact.bin')
+ self.updater.check_for_update()
+ objects = set(self.git(self.updated.METADATA_ROOT, 'cat-file', '--batch-all-objects', '--batch-check=%(objectname)').splitlines())
+ self.assertIn(target, objects)
+ self.assertIn(middle, objects)
+ self.assertNotIn(target_blob, objects)
+ self.assertNotIn(obsolete_blob, objects)
+ metadata_fetches = sum('fetch' in command for command in self.commands)
+ self.assertTrue(self.updater.fetch_update())
+ self.assertEqual(sum('fetch' in command for command in self.commands), metadata_fetches + 2)
+ objects = set(self.git(self.merged, 'cat-file', '--batch-all-objects', '--batch-check=%(objectname)').splitlines())
+ self.assertIn(target, objects)
+ self.assertNotIn(middle, objects)
+ self.assertIn(target_blob, objects)
+ self.assertNotIn(obsolete_blob, objects)
+ self.assertIn(middle, self.git(self.updated.METADATA_ROOT, 'log', '--first-parent', '--format=%H', f'refs/starpilot/recent/{BRANCH}').splitlines())
+ self.assertEqual((self.finalized / 'artifact.bin').read_bytes(), artifact.read_bytes())
+
+ def test_refresh_versions_fetches_only_metadata_in_staging(self):
+ self.git(self.source, 'config', 'uploadpack.allowFilter', 'true')
+ self.git(self.merged, 'remote', 'set-url', 'origin', self.source.as_uri())
+ artifact = self.source / 'artifact.bin'
+ artifact.write_bytes(os.urandom(128 * 1024))
+ target = self.commit_source('Version metadata to refresh')
+ blob = self.git(self.source, 'rev-parse', 'HEAD:artifact.bin')
+ installed = self.root / 'installed'
+ self.git(self.root, 'clone', '--no-local', str(self.merged), str(installed))
+ self.updated.BASEDIR = str(installed)
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
+ self.git(self.root, 'clone', '--no-local', str(self.merged), str(self.finalized))
+ marker = self.finalized / '.overlay_consistent'
+ marker.touch()
+ self.updater.params.values['IsOffroad'] = True
+ with patch.object(self.updated, 'init_overlay'), \
+ patch('openpilot.starpilot.drive_state.evidence.PhysicalSource', return_value=Mock(update_ready=Mock(return_value=True))):
+ self.assertEqual(self.updater.fast_update(BRANCH, self.initial_commit, versions_only=True), 'versions-listed')
+ objects = set(self.git(self.updated.METADATA_ROOT, 'cat-file', '--batch-all-objects', '--batch-check=%(objectname)').splitlines())
+ self.assertIn(target, objects)
+ self.assertNotIn(blob, objects)
+ self.assertEqual(self.git(installed, 'rev-parse', 'HEAD'), self.initial_commit)
+ self.assertFalse((installed / '.git/FETCH_HEAD').exists())
+ self.assertTrue(marker.exists())
+ self.assertNotIn('DoReboot', self.updater.params.values)
+ self.assertTrue(self.updater.params.values['UpdaterFetchAvailable'])
+ self.assertFalse(self.updater.params.values['UpdateAvailable'])
+
+ def test_scheduled_check_stages_new_commit_when_automatic_downloads_are_enabled(self):
+ (self.source / "panda/README.md").write_text("New automatic download\n")
+ target = self.commit_source("Automatic download after checking")
+ params = self.updater.params
+ params.values["InstallDate"] = "already installed"
+ preference = self.root / "UpdaterAutomaticDownloads"
+ params.get_param_path = lambda key: str(self.root / key)
+ for enabled in (False, True):
+ with self.subTest(enabled=enabled):
+ preference.write_bytes(b"1" if enabled else b"0")
+ helper = Mock()
+ helper.current_request.side_effect = [
+ (self.updated.UserRequest.NONE, 0, None),
+ (self.updated.UserRequest.NONE, 1, None),
+ RuntimeError("test loop complete"),
+ ]
+ with patch.object(self.updated, "Params", return_value=params), \
+ patch.object(self.updated, "Updater", return_value=self.updater), \
+ patch.object(self.updated, "WaitTimeHelper", return_value=helper), \
+ patch.object(self.updated, "init_overlay"), \
+ patch.object(self.updated, "LOCK_FILE", str(self.root / "updater.lock")), \
+ patch.object(self.updater, "set_params"), \
+ self.assertRaisesRegex(RuntimeError, "test loop complete"):
+ self.updated.main()
+ self.assertEqual((self.finalized / ".overlay_consistent").exists(), enabled)
+ self.assertEqual("UpdaterLastFetchTime" in params.values, enabled)
+ self.assertNotIn("DoReboot", params.values)
+ if enabled:
+ self.assertEqual(self.git(self.finalized, "rev-parse", "HEAD"), target)
+ else:
+ self.assertEqual(self.git(self.merged, "rev-parse", "HEAD"), self.initial_commit)
+
+ def test_up_to_date_check_does_not_repeat_automatic_staging(self):
+ params = self.updater.params
+ params.values['InstallDate'] = 'already installed'
+ params.get_param_path = lambda key: str(self.root / key)
+ helper = Mock()
+ helper.current_request.side_effect = [
+ (self.updated.UserRequest.NONE, 0, None),
+ (self.updated.UserRequest.CHECK, 1, None),
+ RuntimeError('test loop complete'),
+ ]
+ with patch.object(self.updated, 'Params', return_value=params), \
+ patch.object(self.updated, 'Updater', return_value=self.updater), \
+ patch.object(self.updated, 'WaitTimeHelper', return_value=helper), \
+ patch.object(self.updated, 'init_overlay'), \
+ patch.object(self.updated, 'LOCK_FILE', str(self.root / 'updater.lock')), \
+ patch.object(self.updater, 'set_params'), \
+ patch.object(self.updater, 'fetch_update') as download, \
+ self.assertRaisesRegex(RuntimeError, 'test loop complete'):
+ self.updated.main()
+ download.assert_not_called()
+ self.assertNotIn('UpdaterLastFetchTime', params.values)
+ self.assertFalse(self.finalized.exists())
+
+ def test_metadata_refresh_completes_while_background_finalization_is_blocked(self):
+ installed = self.root / 'installed'
+ self.git(self.root, 'clone', '--no-local', str(self.merged), str(installed))
+ self.git(installed, 'remote', 'set-url', 'origin', str(self.source))
+ self.updated.BASEDIR = str(installed)
+ (self.source / 'panda/README.md').write_text('New background version')
+ self.commit_source('Background download')
+ entered, release = threading.Event(), threading.Event()
+ finalize = self.updated.finalize_update
+ failures = []
+ def blocked_finalize(*args, **kwargs):
+ entered.set()
+ if not release.wait(8):
+ raise RuntimeError('Test did not release finalization')
+ return finalize(*args, **kwargs)
+ def download():
+ try:
+ self.updater.fetch_update(background=True)
+ except Exception as error:
+ failures.append(error)
+ with patch.object(self.updated, 'finalize_update', side_effect=blocked_finalize):
+ worker = threading.Thread(target=download)
+ worker.start()
+ try:
+ self.assertTrue(entered.wait(4))
+ started = time.monotonic()
+ self.updater.request_check(branch=BRANCH, commit=self.initial_commit)
+ deadline = started + 4
+ while time.monotonic() < deadline:
+ check = self.updater.params.values['UpdaterFastState'].get('check', {})
+ if check.get('completedAt', 0) >= started:
+ break
+ time.sleep(0.01)
+ self.assertEqual(check['state'], 'complete')
+ self.assertGreaterEqual(check['completedAt'], started)
+ self.assertEqual(self.updater.params.values['UpdaterState'], 'finalizing update...')
+ self.assertTrue(self.updater.params.values['UpdaterFastState']['background'])
+ finally:
+ release.set()
+ worker.join(5)
+ self.assertFalse(worker.is_alive())
+ self.assertEqual(failures, [])
+
+ def test_finalized_runtime_files_are_independent_and_git_objects_are_shared(self):
+ (self.source / 'panda/README.md').write_text('Prepared source')
+ self.commit_source('New release')
+ self.updater.fetch_update()
+ source = self.merged / 'panda/README.md'
+ copied = self.finalized / 'panda/README.md'
+ self.assertNotEqual(source.stat().st_ino, copied.stat().st_ino)
+ copied.write_text('Local edit in prepared tree')
+ self.assertEqual(source.read_text(), 'Prepared source')
+ objects = list((self.merged / '.git/objects/pack').glob('*.pack'))
+ self.assertTrue(objects)
+ for obj in objects:
+ final = self.finalized / obj.relative_to(self.merged)
+ self.assertEqual(obj.stat().st_ino, final.stat().st_ino)
+ self.assertFalse(any(command[:2] == ['git', 'gc'] for command in self.commands))
+
def test_invalid_manifest_rejected_before_checkout(self):
self.manifest["schema_version"] = 999
self.write_manifest()
diff --git a/openpilot/system/updated/updated.py b/openpilot/system/updated/updated.py
index 73be579e50..0747694107 100755
--- a/openpilot/system/updated/updated.py
+++ b/openpilot/system/updated/updated.py
@@ -24,7 +24,11 @@ from openpilot.common.version import get_build_metadata
from openpilot.common.vendor_manifest import validate_revision
from openpilot.starpilot.software.update_control import UpdaterControlError, UpdaterControlServer
from openpilot.starpilot.software.preferences import AUTOMATIC_DOWNLOADS, download_permitted
-from openpilot.starpilot.software.fast_update import FastUpdateError, FastUpdateIncompatible, required_os_version, run as run_git
+from openpilot.starpilot.software.fast_update import (
+ FastUpdateError, FastUpdateIncompatible, fetch_files, required_os_version, run as run_git,
+)
+from openpilot.starpilot.software.history import MAX_COMMITS, METADATA_ROOT, commit_history
+from openpilot.starpilot.software.auto_install import InstallSettings, cron_matches, scheduled_restart
LOCK_FILE = os.getenv("UPDATER_LOCK_FILE", "/tmp/safe_staging_overlay.lock")
STAGING_ROOT = os.getenv("UPDATER_STAGING_ROOT", "/data/safe_staging")
@@ -51,16 +55,20 @@ class UserRequest:
FAST = 3
ROLLBACK = 4
VERSIONS = 5
+ DOWNLOAD_VERSION = 8
VERSION = 6
UPDATE = 7
class WaitTimeHelper:
- def __init__(self):
+ def __init__(self, metadata=None, idle_tick=None):
self.ready_event = threading.Event()
self.user_request = UserRequest.NONE
self.request_lock = threading.RLock()
self.request_generation = 0
self.fast_target: tuple[str, str] | tuple[str, str, str] | None = None
+ self.metadata = metadata
+ self.idle_tick = idle_tick
+ self.automatic_pending = False
signal.signal(signal.SIGHUP, self.update_now)
signal.signal(signal.SIGUSR1, self.check_now)
self.control = UpdaterControlServer(self._control_request)
@@ -74,10 +82,10 @@ class WaitTimeHelper:
def _request(self, request: int, *, branch=None, commit=None, selected_commit=None) -> None:
with self.request_lock:
self.user_request = request
- if request in (UserRequest.UPDATE, UserRequest.FAST, UserRequest.ROLLBACK, UserRequest.VERSIONS, UserRequest.VERSION):
+ if request in (UserRequest.UPDATE, UserRequest.FAST, UserRequest.ROLLBACK, UserRequest.VERSIONS, UserRequest.VERSION, UserRequest.DOWNLOAD_VERSION):
if not isinstance(branch, str) or not isinstance(commit, str):
raise ValueError("Update source identity is required")
- if request == UserRequest.VERSION:
+ if request in (UserRequest.VERSION, UserRequest.DOWNLOAD_VERSION):
if not isinstance(selected_commit, str):
raise ValueError("Selected version is required")
self.fast_target = (branch, commit, selected_commit)
@@ -89,9 +97,12 @@ class WaitTimeHelper:
self.ready_event.set()
def _control_request(self, action: str, *, branch=None, commit=None, selected_commit=None) -> None:
+ if self.metadata is not None and action in ('check', 'versions'):
+ self.metadata(branch=branch, commit=commit, download_after=action == 'check')
+ return
request = {'update': UserRequest.UPDATE, 'check': UserRequest.CHECK, 'download': UserRequest.FETCH,
'fast': UserRequest.FAST, 'rollback': UserRequest.ROLLBACK,
- 'versions': UserRequest.VERSIONS, 'version': UserRequest.VERSION}.get(action)
+ 'versions': UserRequest.VERSIONS, 'version': UserRequest.VERSION, 'download-version': UserRequest.DOWNLOAD_VERSION}.get(action)
if request is not None:
self._request(request, branch=branch, commit=commit, selected_commit=selected_commit)
@@ -101,32 +112,48 @@ class WaitTimeHelper:
def check_now(self, signum: int, frame) -> None:
cloudlog.info("caught SIGUSR1, checking for updates")
- self._request(UserRequest.CHECK)
+ self._control_request('check')
def current_request(self) -> tuple[int, int, tuple[str, str] | tuple[str, str, str] | None]:
with self.request_lock:
self.ready_event.clear()
+ self.automatic_pending = False
return self.user_request, self.request_generation, self.fast_target
+ def wake_automatic(self):
+ with self.request_lock:
+ self.automatic_pending = True
+ self.ready_event.set()
+
def finish_request(self, generation: int) -> bool:
with self.request_lock:
if self.request_generation != generation:
return False
self.user_request = UserRequest.NONE
self.fast_target = None
+ if self.automatic_pending:
+ return False
self.ready_event.clear()
return True
def sleep(self, t: float) -> None:
- self.ready_event.wait(timeout=t)
+ deadline = time.monotonic() + t
+ while not self.ready_event.is_set():
+ tick = getattr(self, 'idle_tick', None)
+ if tick is not None:
+ tick()
+ remaining = deadline - time.monotonic()
+ if remaining <= 0 or self.ready_event.wait(timeout=min(30, remaining)):
+ return
def write_time_to_param(params, param) -> None:
t = datetime.datetime.now(datetime.UTC).replace(tzinfo=None)
params.put(param, t, block=True)
-def run(cmd: list[str], cwd: str | None = None) -> str:
+def run(cmd: list[str], cwd: str | None = None, *, download: bool = False, progress=None, cancelled=None, stdin=None, timeout=None) -> str:
if cmd and cmd[0] == 'git':
- return run_git(cmd, cwd, timeout=300 if 'fetch' in cmd or 'gc' in cmd else 120)
+ return run_git(cmd, cwd, timeout=timeout or (300 if download or 'fetch' in cmd or 'gc' in cmd else 120),
+ download=download, progress=progress, cancelled=cancelled, stdin=stdin)
return subprocess.check_output(cmd, cwd=cwd, stderr=subprocess.STDOUT, encoding='utf8')
@@ -234,7 +261,7 @@ def init_overlay() -> None:
cloudlog.info(f"git diff output:\n{git_diff}")
-def finalize_update() -> None:
+def finalize_update(progress=None) -> None:
"""Take the current OverlayFS merged view and finalize a copy outside of
OverlayFS, ready to be swapped-in at BASEDIR. Copy using shutil.copytree"""
@@ -246,19 +273,45 @@ def finalize_update() -> None:
# Copy the merged overlay view and set the update ready flag
if os.path.exists(FINALIZED):
shutil.rmtree(FINALIZED)
- shutil.copytree(OVERLAY_MERGED, FINALIZED, symlinks=True)
+ total = sum(not os.path.islink(os.path.join(root, name)) for root, _, files in os.walk(OVERLAY_MERGED) for name in files)
+ copied = 0
+ reported = 0.0
+ roots = (Path(OVERLAY_UPPER), Path(BASEDIR)) if os.path.ismount(OVERLAY_MERGED) else (Path(OVERLAY_MERGED),)
+ def copy_file(source, destination):
+ nonlocal copied, reported
+ relative = Path(source).relative_to(OVERLAY_MERGED)
+ immutable = re.fullmatch(r'\.git/objects/(?:[0-9a-f]{2}/[0-9a-f]{38}|pack/pack-[0-9a-f]{40}\.(?:pack|idx))', relative.as_posix())
+ linked = False
+ if immutable:
+ # Git objects are immutable; worktree files, refs and indexes remain independent copies.
+ for root in roots:
+ candidate = root / relative
+ try:
+ if not candidate.is_symlink():
+ os.link(candidate, destination)
+ linked = True
+ break
+ except OSError:
+ pass
+ if not linked:
+ shutil.copy2(source, destination)
+ copied += 1
+ now = time.monotonic()
+ if progress is not None and (now - reported >= 0.25 or copied == total):
+ progress(f'Copying update files: {copied}/{total} ({copied * 100 // max(1, total)}%)', copied * 100 / max(1, total))
+ reported = now
+ return destination
+ started = time.monotonic()
+ shutil.copytree(OVERLAY_MERGED, FINALIZED, symlinks=True, copy_function=copy_file)
+ cloudlog.event('update copy complete', duration=time.monotonic() - started, files=copied)
+ if progress is not None:
+ progress('Verifying the prepared update...', None)
run(["git", "reset", "--hard", "--no-recurse-submodules"], FINALIZED)
validate_revision(FINALIZED, "HEAD")
- cloudlog.info("Starting git cleanup in finalized update")
- t = time.monotonic()
- try:
- run(["git", "gc"], FINALIZED)
- cloudlog.event("Done git cleanup", duration=time.monotonic() - t)
- except subprocess.CalledProcessError:
- cloudlog.exception(f"Failed git cleanup, took {time.monotonic() - t:.3f} s")
-
+ if progress is not None:
+ progress('Syncing the prepared update to storage...', None)
set_consistent_flag(True)
cloudlog.info("done finalizing overlay")
@@ -292,11 +345,96 @@ def handle_agnos_update() -> None:
class Updater:
- def __init__(self):
+ def __init__(self, install_settings=None):
self.params = Params()
self.branches: dict[str, str] = {}
self._branches_checked = False
self._has_internet: bool = False
+ self._progress_lock = threading.RLock()
+ self._metadata_lock = threading.Lock()
+ self._request_lock = threading.Lock()
+ self._check_thread = None
+ self._pending_check = None
+ self._closed = threading.Event()
+ self._checked_at = 0.0
+ self._checked_branch = None
+ self.wake_automatic = None
+ self.install_settings = install_settings if install_settings is not None else InstallSettings()
+
+ def maybe_install(self, idle=lambda: True) -> bool:
+ from zoneinfo import ZoneInfo
+ value = self.install_settings.read()
+ now = datetime.datetime.now(ZoneInfo(value.get('timezone', 'UTC') if value else 'UTC'))
+ if not value or not value['enabled'] or not system_time_valid() or not cron_matches(value['cron'], now):
+ return False
+ from openpilot.starpilot.drive_state.evidence import PhysicalSource
+ source = PhysicalSource()
+ def parked():
+ deadline = time.monotonic() + 1.5
+ while True:
+ if source.update_ready(self.params.get_bool('IsOffroad')):
+ return True
+ if time.monotonic() >= deadline:
+ return False
+ time.sleep(0.02)
+ def ready():
+ if (not idle() or self.params.get('UpdaterState') != 'idle' or
+ self._check_thread is not None or not self.update_ready or Path(FINALIZED, '.overlay_consistent').is_symlink()):
+ return False
+ validate_revision(FINALIZED, 'HEAD')
+ return True
+ try:
+ return scheduled_restart(self.params, self.install_settings, ready, parked, now)
+ except (OSError, ValueError, subprocess.SubprocessError):
+ cloudlog.exception('Scheduled update restart was not admitted')
+ return False
+ finally:
+ source.close()
+
+ def _write_progress(self, **values):
+ if not hasattr(self, '_progress_lock'):
+ self._progress_lock = threading.RLock()
+ with self._progress_lock:
+ previous = self.params.get('UpdaterFastState')
+ state = dict(previous) if isinstance(previous, dict) else {'version': 1, 'stage': 'complete', 'detail': ''}
+ state.update(values)
+ self.params.put('UpdaterFastState', state, block=True)
+
+ def progress(self, stage, detail, *, background=False, percent=None):
+ if percent is None and (match := re.search(r'(\d+)%', detail)):
+ percent = min(100, int(match[1]))
+ self._write_progress(version=1, stage=stage, detail=detail[:512], background=background, percent=percent)
+
+ def request_check(self, *, branch=None, commit=None, download_after=False):
+ with self._request_lock:
+ download_after = download_after or bool(self._pending_check and self._pending_check[2])
+ self._pending_check = (branch or self.target_branch, commit, download_after)
+ if self._check_thread is None:
+ self._check_thread = threading.Thread(target=self._run_checks, name='updater-metadata', daemon=True)
+ self._check_thread.start()
+
+ def _run_checks(self):
+ while not self._closed.is_set():
+ with self._request_lock:
+ request, self._pending_check = self._pending_check, None
+ if request is None:
+ self._check_thread = None
+ return
+ branch, commit, download_after = request
+ try:
+ if commit is not None and self.get_commit_hash(BASEDIR) != commit:
+ raise FastUpdateError('Installed revision changed; refresh and try again')
+ self.check_for_update(branch)
+ if (download_after and self.wake_automatic is not None and not self.params.get_bool('DoReboot') and
+ download_permitted(self.params, manual=False) and self.update_available and not self.latest_update_ready):
+ self.wake_automatic()
+ except Exception as error:
+ self._write_progress(check={'state': 'error', 'branch': branch, 'detail': str(error)[:512], 'completedAt': time.monotonic()})
+
+ def close(self):
+ self._closed.set()
+ if self._check_thread is not None:
+ self._check_thread.join(timeout=6)
@property
def has_internet(self) -> bool:
@@ -318,19 +456,28 @@ class Updater:
@property
def update_ready(self) -> bool:
consistent_file = Path(os.path.join(FINALIZED, ".overlay_consistent"))
- if self._branches_checked and consistent_file.is_file() and self.target_branch in self.branches:
- hash_mismatch = self.get_commit_hash(BASEDIR) != self.branches[self.target_branch]
- branch_mismatch = self.get_branch(BASEDIR) != self.target_branch
- on_target_branch = self.get_branch(FINALIZED) == self.target_branch
- finalized_at_remote_head = self.get_commit_hash(FINALIZED) == self.branches[self.target_branch]
- return ((hash_mismatch or branch_mismatch) and on_target_branch and finalized_at_remote_head)
+ branch, branches = self.target_branch, self.branches
+ if self._branches_checked and consistent_file.is_file() and branch in branches:
+ branch_mismatch = self.get_branch(BASEDIR) != branch
+ on_target_branch = self.get_branch(FINALIZED) == branch
+ staged = getattr(self, '_staged_target', None)
+ expected = staged[1] if staged is not None and staged[0] == branch else branches[branch]
+ hash_mismatch = self.get_commit_hash(BASEDIR) != expected
+ finalized_at_target = self.get_commit_hash(FINALIZED) == expected
+ return ((hash_mismatch or branch_mismatch) and on_target_branch and finalized_at_target)
return False
+ @property
+ def latest_update_ready(self) -> bool:
+ staged = getattr(self, '_staged_target', None)
+ return self.update_ready and (staged is None or staged == (self.target_branch, self.branches.get(self.target_branch)))
+
@property
def update_available(self) -> bool:
- if self._branches_checked and os.path.isdir(OVERLAY_MERGED) and self.target_branch in self.branches:
- hash_mismatch = self.get_commit_hash(OVERLAY_MERGED) != self.branches[self.target_branch]
- branch_mismatch = self.get_branch(OVERLAY_MERGED) != self.target_branch
+ branch, branches = self.target_branch, self.branches
+ if self._branches_checked and branch in branches:
+ hash_mismatch = self.get_commit_hash(BASEDIR) != branches[branch]
+ branch_mismatch = self.get_branch(BASEDIR) != branch
return hash_mismatch or branch_mismatch
return False
@@ -410,41 +557,70 @@ class Updater:
remaining = max(HOURS_NO_CONNECTIVITY_MAX - dt_uptime_onroad, 1)
set_offroad_alert("Offroad_ConnectivityNeededPrompt", True, extra_text=f"{remaining} hour{'' if remaining == 1 else 's'}.")
- def check_for_update(self) -> None:
+ def check_for_update(self, branch: str | None = None) -> None:
+ branch = branch or self.target_branch
+ with self._metadata_lock:
+ self._write_progress(check={'state': 'checking', 'branch': branch, 'detail': 'Fetching version metadata...'})
+ try:
+ self._check_for_update(branch)
+ self._checked_at, self._checked_branch = time.monotonic(), branch
+ self._write_progress(check={'state': 'complete', 'branch': branch, 'detail': 'Version metadata refreshed.',
+ 'completedAt': time.monotonic()})
+ except Exception as error:
+ self._write_progress(check={'state': 'error', 'branch': branch, 'detail': str(error)[:512], 'completedAt': time.monotonic()})
+ raise
+
+ def _check_for_update(self, branch) -> None:
cloudlog.info("checking for updates")
excluded_branches = ('release2', 'release2-staging')
self._branches_checked = False
self.params.put("UpdaterOSUpdate", {}, block=True)
- setup_git_options(OVERLAY_MERGED)
+ metadata = Path(METADATA_ROOT)
+ metadata.parent.mkdir(parents=True, exist_ok=True)
+ if not (metadata / 'HEAD').is_file():
+ run(['git', 'init', '--bare', str(metadata)], str(metadata.parent))
+ remote = run(['git', 'remote', 'get-url', 'origin'], BASEDIR).strip()
+ run(['git', 'config', 'remote.origin.url', remote], str(metadata))
+ setup_git_options(str(metadata))
try:
- output = run(["git", "ls-remote", "--heads", "origin"], OVERLAY_MERGED)
+ output = run(["git", "ls-remote", "--heads", "origin"], str(metadata), cancelled=self._closed.is_set, timeout=30)
except subprocess.CalledProcessError:
self._has_internet = False
raise
self._has_internet = True
- self.branches.clear()
+ branches = {}
for line in output.split('\n'):
ls_remotes_re = r'(?P\b[0-9a-f]{5,40}\b)(\s+)(refs\/heads\/)(?P.*$)'
x = re.fullmatch(ls_remotes_re, line.strip())
if x is not None and x.group('branch_name') not in excluded_branches:
- self.branches[x.group('branch_name')] = x.group('commit_sha')
- cur_branch = self.get_branch(OVERLAY_MERGED)
- cur_commit = self.get_commit_hash(OVERLAY_MERGED)
+ branches[x.group('branch_name')] = x.group('commit_sha')
+ self.branches = branches
+ cur_branch = self.get_branch(BASEDIR)
+ cur_commit = self.get_commit_hash(BASEDIR)
self._branches_checked = True
- write_time_to_param(self.params, "UpdaterLastCheckTime")
- new_branch = self.target_branch
+ new_branch = branch or self.target_branch
new_commit = self.branches.get(new_branch)
if new_commit is None:
cloudlog.info("target branch %s is not published on origin; no update available", new_branch)
+ self.params.put('UpdaterAvailableBranches', ','.join(self.branches), block=True)
+ self.params.put_bool('UpdaterFetchAvailable', False, block=True)
+ self.params.put_bool('UpdateAvailable', False, block=True)
+ write_time_to_param(self.params, 'UpdaterLastCheckTime')
return
+ # Fetch history and trees, not artifact contents, for the version list.
+ def metadata_progress(detail):
+ self._write_progress(check={'state': 'checking', 'branch': branch, 'detail': detail[:512]})
+ run(["git", "fetch", '--progress', f"--depth={MAX_COMMITS}", "--filter=blob:none", "--no-tags", "--no-recurse-submodules",
+ "origin", f"+{new_commit}:refs/remotes/origin/{new_branch}"], str(metadata),
+ progress=metadata_progress, cancelled=self._closed.is_set, timeout=30)
+ run(["git", "update-ref", f"refs/starpilot/recent/{new_branch}", new_commit], str(metadata))
if AGNOS:
try:
- if cur_commit != new_commit:
- run(["git", "fetch", "--depth=1", "--filter=blob:none", "--no-tags", "--no-recurse-submodules", "origin", new_commit], OVERLAY_MERGED)
- version = required_os_version(run(["git", "show", f"{new_commit}:launch_env.sh"], OVERLAY_MERGED))
+ version = required_os_version(run(["git", "show", f"{new_commit}:launch_env.sh"], str(metadata),
+ download=True, cancelled=self._closed.is_set, timeout=30))
current_os = HARDWARE.get_os_version()
if version and current_os:
self.params.put("UpdaterOSUpdate", {"branch": new_branch, "required": version != current_os}, block=True)
@@ -454,8 +630,12 @@ class Updater:
cloudlog.info(f"update available, {cur_branch} ({str(cur_commit)[:7]}) -> {new_branch} ({str(new_commit)[:7]})")
else:
cloudlog.info(f"up to date on {cur_branch} ({str(cur_commit)[:7]})")
+ self.params.put("UpdaterAvailableBranches", ','.join(self.branches), block=True)
+ self.params.put_bool("UpdaterFetchAvailable", self.update_available, block=True)
+ self.params.put_bool("UpdateAvailable", self.update_ready, block=True)
+ write_time_to_param(self.params, 'UpdaterLastCheckTime')
- def fast_update(self, branch: str, commit: str, selected_commit=None, *, rollback=False, versions_only=False, automatic=False) -> str:
+ def fast_update(self, branch: str, commit: str, selected_commit=None, *, rollback=False, versions_only=False, automatic=False, download_only=False) -> str:
from openpilot.starpilot.drive_state.evidence import PhysicalSource
from openpilot.starpilot.software.fast_update import fast_update
@@ -478,11 +658,47 @@ class Updater:
self._branches_checked = False
def progress(stage, detail):
- self.params.put("UpdaterFastState", {"version": 1, "stage": stage, "detail": detail[:512], "branch": branch}, block=True)
+ self.progress(stage, detail)
try:
+ if versions_only:
+ initial_branch = self.get_branch(BASEDIR)
+ def admitted():
+ if not parked() or self.get_commit_hash(BASEDIR) != commit or self.get_branch(BASEDIR) != initial_branch:
+ raise FastUpdateError("Update source or parked state changed")
+ admitted()
+ run(["git", "check-ref-format", "--branch", branch], BASEDIR)
+ progress('fetching', 'Fetching version metadata...')
+ self.check_for_update(branch)
+ admitted()
+ if branch not in self.branches:
+ raise FastUpdateError("Target branch is no longer available")
+ progress('complete', 'Recent versions are ready to review.')
+ return 'versions-listed'
+ if download_only:
+ def admitted():
+ if not parked() or self.get_commit_hash(BASEDIR) != commit:
+ raise FastUpdateError('Installed revision or parked state changed; refresh and try again')
+ admitted()
+ self.check_for_update(branch)
+ members = commit_history(Path(METADATA_ROOT), self.branches.get(branch, ''), first_parent=True)
+ if branch == self.get_branch(BASEDIR):
+ members += commit_history(Path(BASEDIR), commit, first_parent=True)
+ if not any(row['hash'] == selected_commit for row in members):
+ raise FastUpdateError('Selected version is no longer in branch history; refresh and try again')
+ admitted()
+ self.params.put('UpdaterTargetBranch', branch, block=True)
+ if not self.fetch_update(selected_commit=selected_commit, admitted=admitted):
+ raise FastUpdateError('Selected version could not be downloaded')
+ admitted()
+ self.set_params(True, 0, None)
+ return 'downloaded'
+ def installed_progress(stage, detail):
+ if stage == 'complete':
+ self.params.put('UpdaterTargetBranch', self.get_branch(BASEDIR), block=True)
+ progress(stage, detail)
return fast_update(Path(BASEDIR), branch, expected_commit=commit, params=self.params, parked=parked,
- current_os=HARDWARE.get_os_version(), invalidate=invalidate, rollback=rollback, progress=progress,
+ current_os=HARDWARE.get_os_version(), invalidate=invalidate, rollback=rollback, progress=installed_progress,
selected_commit=selected_commit, versions_only=versions_only)
except FastUpdateIncompatible:
if not automatic:
@@ -499,7 +715,6 @@ class Updater:
admitted()
progress("preparing", "Preparing full software update")
self.params.put("UpdaterTargetBranch", branch, block=True)
- init_overlay()
self._branches_checked = False
self.params.put("UpdaterState", "checking...", block=True)
if phone_uplink_active():
@@ -513,10 +728,10 @@ class Updater:
self.params.put_bool("DoReboot", True, block=True)
return "reboot-requested"
- def fetch_update(self) -> bool:
+ def fetch_update(self, *, background=False, selected_commit=None, admitted=None) -> bool:
if phone_uplink_active():
return False
- if not self._branches_checked:
+ if not self._branches_checked or self._checked_branch != self.target_branch:
self.check_for_update()
if self.target_branch not in self.branches:
cloudlog.info("skipping fetch of unpublished target branch %s", self.target_branch)
@@ -525,6 +740,11 @@ class Updater:
cloudlog.info("attempting git fetch inside staging overlay")
self.params.put("UpdaterState", "downloading...", block=True)
+ self.progress('preparing', 'Preparing download staging...', background=background)
+ init_overlay()
+ self.progress('fetching', 'Downloading the selected version...', background=background)
+ def git_progress(detail):
+ self.progress('fetching', detail, background=background)
# TODO: cleanly interrupt this and invalidate old update
set_consistent_flag(False)
@@ -535,22 +755,37 @@ class Updater:
run(["git", "config", "--replace-all", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"], OVERLAY_MERGED)
branch = self.target_branch
- git_fetch_output = run(["git", "fetch", "--no-recurse-submodules", "origin", branch], OVERLAY_MERGED)
- cloudlog.info("git fetch success: %s", git_fetch_output)
-
# Validate using the running updater before checking out or executing any update.
# A branch containing gitlinks or an invalid dependency manifest is not installable.
- fetched_commit = run(["git", "rev-parse", "FETCH_HEAD^{commit}"], OVERLAY_MERGED).strip()
+ fetched_commit = selected_commit or self.branches[branch]
+ run(['git', 'fetch', '--progress', '--depth=1', '--filter=blob:none', '--no-tags', '--no-recurse-submodules',
+ 'origin', f'+{fetched_commit}:refs/remotes/origin/{branch}'], OVERLAY_MERGED, progress=git_progress)
+ # Fetch the manifest under the download guard before read-only validation.
+ if run(["git", "ls-tree", fetched_commit, "--", "upstream-sync.json"], OVERLAY_MERGED).split()[:1] == ['100644']:
+ run(["git", "show", f"{fetched_commit}:upstream-sync.json"], OVERLAY_MERGED, download=True)
validate_revision(OVERLAY_MERGED, fetched_commit)
+ def git(*args, stdin=None):
+ return run(['git', *args], OVERLAY_MERGED, progress=git_progress, stdin=stdin)
+ fetch_files(git, fetched_commit)
+ run(["git", "update-ref", f"refs/starpilot/recent/{branch}", fetched_commit], OVERLAY_MERGED)
+ if admitted is not None:
+ admitted()
cloudlog.info("git reset in progress")
+ self.progress('applying', 'Writing downloaded files...', background=background)
+ def apply_progress(detail):
+ self.progress('applying', detail, background=background)
+ installed_commit = self.get_commit_hash(BASEDIR)
+ installed_branch = self.get_branch(BASEDIR)
+ run(['git', 'update-ref', 'refs/starpilot/previous', installed_commit], OVERLAY_MERGED)
+ run(['git', 'config', '--local', 'starpilot.previousVersion', f'{installed_commit} {installed_branch}'], OVERLAY_MERGED)
cmds = [
- ["git", "checkout", "--force", "--no-recurse-submodules", "-B", branch, fetched_commit],
+ ["git", "checkout", '--progress', "--force", "--no-recurse-submodules", "-B", branch, fetched_commit],
["git", "branch", "--set-upstream-to", f"origin/{branch}"],
["git", "reset", "--hard", "--no-recurse-submodules"],
["git", "clean", "-xdff"],
]
- r = [run(cmd, OVERLAY_MERGED) for cmd in cmds]
+ r = [run(cmd, OVERLAY_MERGED, download=cmd[1] in ('checkout', 'reset'), progress=apply_progress) for cmd in cmds]
validate_revision(OVERLAY_MERGED, "HEAD")
cloudlog.info("git reset success: %s", '\n'.join(r))
@@ -560,18 +795,27 @@ class Updater:
# Create the finalized, ready-to-swap update
self.params.put("UpdaterState", "finalizing update...", block=True)
- finalize_update()
+ self.progress('finalizing', 'Preparing the downloaded update...', background=background)
+ finalize_update(progress=lambda detail, percent: self.progress('finalizing', detail, background=background, percent=percent))
+ self._staged_target = (branch, fetched_commit)
+ self.progress('complete', 'Downloaded update is ready to install.', background=background)
cloudlog.info("finalize success!")
return True
def recover_fast_state(params):
previous = params.get("UpdaterFastState")
- if isinstance(previous, dict) and previous.get("stage") not in ("complete", "error"):
- params.put("UpdaterFastState", {
- "version": 1, "stage": "error",
- "detail": "Update process restarted before completion; check the installed version and retry.",
- }, block=True)
+ if not isinstance(previous, dict):
+ return
+ state = dict(previous)
+ if state.get('check', {}).get('state') == 'checking':
+ state['check'] = {**state['check'], 'state': 'error', 'completedAt': time.monotonic(),
+ 'detail': 'Metadata check was interrupted when the updater restarted. Retry the check.'}
+ if state.get('stage') not in ('complete', 'error'):
+ state.update(version=1, stage='error',
+ detail='Update process restarted before completion; check the installed version and retry.')
+ if state != previous:
+ params.put('UpdaterFastState', state, block=True)
def main() -> None:
@@ -597,7 +841,10 @@ def main() -> None:
updater = Updater()
update_failed_count = max(0, params.get("UpdateFailedCount") or 0)
- wait_helper = WaitTimeHelper()
+ wait_helper = WaitTimeHelper(metadata=updater.request_check)
+ wait_helper.idle_tick = lambda: updater.maybe_install(lambda: not wait_helper.ready_event.is_set())
+ updater.wake_automatic = wait_helper.wake_automatic
+ atexit.register(updater.close)
# invalidate old finalized update
set_consistent_flag(False)
@@ -613,14 +860,18 @@ def main() -> None:
# Attempt an update
exception = None
- fast_requested = requested in (UserRequest.UPDATE, UserRequest.FAST, UserRequest.ROLLBACK, UserRequest.VERSIONS, UserRequest.VERSION)
+ fast_requested = requested in (
+ UserRequest.UPDATE, UserRequest.FAST, UserRequest.ROLLBACK, UserRequest.VERSIONS, UserRequest.VERSION, UserRequest.DOWNLOAD_VERSION,
+ )
try:
if fast_requested:
update_failed_count += 1
- params.put("UpdaterState", "updating...", block=True)
+ params.put("UpdaterState", "downloading..." if requested == UserRequest.DOWNLOAD_VERSION else "updating...", block=True)
if fast_target is None:
raise ValueError("Update source identity is required")
- if requested == UserRequest.VERSIONS:
+ if requested == UserRequest.DOWNLOAD_VERSION:
+ updater.fast_update(*fast_target, download_only=True)
+ elif requested == UserRequest.VERSIONS:
updater.fast_update(*fast_target, versions_only=True)
elif requested == UserRequest.UPDATE:
updater.fast_update(*fast_target, automatic=True)
@@ -632,9 +883,6 @@ def main() -> None:
if requested != UserRequest.VERSIONS:
write_time_to_param(params, "LastUpdateTime")
else:
- # TODO: reuse overlay from previous updated instance if it looks clean
- init_overlay()
-
# ensure we have some params written soon after startup
updater.set_params(False, update_failed_count, exception)
@@ -646,21 +894,27 @@ def main() -> None:
update_failed_count += 1
# check for update
- params.put("UpdaterState", "checking...", block=True)
- updater.check_for_update()
+ if requested == UserRequest.CHECK or updater._checked_branch != updater.target_branch or time.monotonic() - updater._checked_at > 60:
+ updater.check_for_update()
# download update
last_fetch = params.get("UpdaterLastFetchTime")
timed_out = last_fetch is None or (datetime.datetime.now(datetime.UTC).replace(tzinfo=None) - last_fetch > datetime.timedelta(days=3))
user_requested_fetch = requested == UserRequest.FETCH
- if phone_uplink_active():
+ if params.get_bool('DoReboot'):
+ cloudlog.info('skipping fetch, restart pending')
+ elif requested == UserRequest.CHECK:
+ cloudlog.info('metadata-only check complete')
+ elif phone_uplink_active():
cloudlog.info("skipping fetch, phone uplink forbids updates")
elif params.get_bool("NetworkMetered") and not timed_out and not user_requested_fetch:
cloudlog.info("skipping fetch, connection metered")
- elif not download_permitted(params, manual=user_requested_fetch, check_only=requested == UserRequest.CHECK):
- cloudlog.info("skipping fetch, check-only request or automatic downloads disabled")
+ elif not download_permitted(params, manual=user_requested_fetch):
+ cloudlog.info("skipping fetch, automatic downloads disabled")
+ elif not user_requested_fetch and (updater.latest_update_ready or not updater.update_available):
+ cloudlog.info("skipping fetch, checked version is already installed or staged")
else:
- if updater.fetch_update():
+ if updater.fetch_update(background=not user_requested_fetch):
write_time_to_param(params, "UpdaterLastFetchTime")
update_failed_count = 0
except subprocess.CalledProcessError as e:
@@ -683,7 +937,7 @@ def main() -> None:
update_successful = (update_failed_count == 0)
if fast_requested:
if exception is not None:
- params.put("UpdaterFastState", {"version": 1, "stage": "error", "detail": exception[:512]}, block=True)
+ updater.progress('error', exception)
params.put("UpdateFailedCount", update_failed_count, block=True)
if exception is None:
params.remove("LastUpdateException")