mirror of
https://github.com/fluxerapp/fluxer
synced 2026-10-17 13:05:32 +09:00
1094 lines
38 KiB
TypeScript
1094 lines
38 KiB
TypeScript
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
import {createHash} from 'node:crypto';
|
|
import {BUILD_CHANNEL} from '@electron/common/BuildChannel';
|
|
import {errorMessage} from '@electron/common/ErrorMessage';
|
|
import {jitteredExponentialDelay} from '@electron/common/ExponentialBackoff';
|
|
import type {DesktopUpdateProbe} from '@electron/main/DesktopUpdateRun';
|
|
import {ModuleDownloadRate} from '@electron/main/ModuleDownloadRate';
|
|
import {type DesktopModuleUpdateManifest, resolveDesktopModuleArchitecture} from '@electron/main/ModuleManifest';
|
|
import {
|
|
type ModuleManifestDocument,
|
|
ModuleManifestFetchError,
|
|
ModuleManifestRepository,
|
|
} from '@electron/main/ModuleManifestRepository';
|
|
import {
|
|
describeErrorChain,
|
|
isDeterministicPackageFailure,
|
|
isModulePackageStall,
|
|
isTransientServerStatus,
|
|
ModulePackageFetchError,
|
|
ModulePackageInstaller,
|
|
type ModulePackageInstallerReport,
|
|
ModulePackageInstallerReportType,
|
|
ModulePackageInstallPhase,
|
|
} from '@electron/main/ModulePackageInstaller';
|
|
import {
|
|
MODULE_BOOT_ATTEMPT_ROLLBACK_THRESHOLD,
|
|
type ModuleLaunchAttempt,
|
|
ModuleManifestEquivocationError,
|
|
type ModuleManifestFeedIdentity,
|
|
type ModuleManifestFeedObservation,
|
|
ModuleManifestRollbackError,
|
|
type ModuleStore,
|
|
sameModuleMap,
|
|
} from '@electron/main/ModuleStore';
|
|
import {
|
|
type ModulePlan,
|
|
type ModulePlanItem,
|
|
ModulePlanItemRequirement,
|
|
ModuleUnreachableLaunchDecision,
|
|
ModuleUpdatePlanner,
|
|
ModuleUpdaterBlockReason,
|
|
type ServedModuleSelection,
|
|
} from '@electron/main/ModuleUpdatePlanner';
|
|
import {compareModuleVersions, type ModuleVersion, parseModuleVersion} from '@electron/main/ModuleVersion';
|
|
import {resolveDesktopPackageOrigin} from '@electron/main/ShellDownloadFormats';
|
|
import type {DesktopModuleEnsureResult} from '@fluxer/desktop_ipc/src/ModuleContract';
|
|
import {DESKTOP_RENDERER_MODULE_NAME, DesktopModuleEnsureStatus} from '@fluxer/desktop_ipc/src/ModuleContract';
|
|
|
|
const MODULE_UPDATER_BACKOFF_BASE_MS = 1000;
|
|
const MODULE_UPDATER_BACKOFF_CAP_MS = 30000;
|
|
const MODULE_UPDATER_NETWORK_ERROR_SAMPLE_RATE = 0.01;
|
|
|
|
const MODULE_ENSURE_MANIFEST_BACKOFF_MS = 30000;
|
|
const CAUSE_CHAIN_LIMIT = 8;
|
|
const STORAGE_FULL_CODES = new Set(['ENOSPC', 'EDQUOT', 'EROFS', 'EFBIG']);
|
|
|
|
export const ModuleUpdaterStatus = Object.freeze({
|
|
CHECKING: 'checking',
|
|
DOWNLOADING: 'downloading',
|
|
INSTALLING: 'installing',
|
|
VERIFYING: 'verifying',
|
|
RETRY_WAIT: 'retry-wait',
|
|
BLOCKED_UPDATE_REQUIRED: 'blocked-update-required',
|
|
BLOCKED_SHELL_UPDATE: 'blocked-shell-update',
|
|
LAUNCHING: 'launching',
|
|
UNREACHABLE_LAUNCH: 'unreachable-launch',
|
|
} as const);
|
|
|
|
export type ModuleUpdaterStatus = (typeof ModuleUpdaterStatus)[keyof typeof ModuleUpdaterStatus];
|
|
|
|
const ModuleUpdaterReportType = Object.freeze({
|
|
NETWORK_ERROR: 'network-error',
|
|
MANIFEST_ROLLBACK: 'manifest-rollback',
|
|
MANIFEST_EQUIVOCATION: 'manifest-equivocation',
|
|
PACKAGE_HASH_MISMATCH: 'package-hash-mismatch',
|
|
PACKAGE_MISSING: 'package-missing',
|
|
PACKAGE_REJECTED: 'package-rejected',
|
|
STORAGE_ERROR: 'storage-error',
|
|
ROLLBACK: 'rollback',
|
|
ROLLBACK_FLOOR_BYPASS: 'rollback-floor-bypass',
|
|
BUNDLED_RENDERER_PREFERRED: 'bundled-renderer-preferred',
|
|
SHELL_INCOMPATIBLE_RETIRED: 'shell-incompatible-retired',
|
|
BLOCKED: 'blocked',
|
|
} as const);
|
|
|
|
type ModuleUpdaterReportType = (typeof ModuleUpdaterReportType)[keyof typeof ModuleUpdaterReportType];
|
|
|
|
const MODULE_UPDATER_REPORT_SAMPLE_RATES: Readonly<Record<ModuleUpdaterReportType, number>> = Object.freeze({
|
|
[ModuleUpdaterReportType.NETWORK_ERROR]: MODULE_UPDATER_NETWORK_ERROR_SAMPLE_RATE,
|
|
[ModuleUpdaterReportType.MANIFEST_ROLLBACK]: 1,
|
|
[ModuleUpdaterReportType.MANIFEST_EQUIVOCATION]: 1,
|
|
[ModuleUpdaterReportType.PACKAGE_HASH_MISMATCH]: 1,
|
|
[ModuleUpdaterReportType.PACKAGE_MISSING]: 1,
|
|
[ModuleUpdaterReportType.PACKAGE_REJECTED]: 1,
|
|
[ModuleUpdaterReportType.STORAGE_ERROR]: 1,
|
|
[ModuleUpdaterReportType.ROLLBACK]: 1,
|
|
[ModuleUpdaterReportType.ROLLBACK_FLOOR_BYPASS]: 1,
|
|
[ModuleUpdaterReportType.BUNDLED_RENDERER_PREFERRED]: 1,
|
|
[ModuleUpdaterReportType.SHELL_INCOMPATIBLE_RETIRED]: 1,
|
|
[ModuleUpdaterReportType.BLOCKED]: 1,
|
|
});
|
|
|
|
export {ModuleUpdaterBlockReason};
|
|
|
|
export interface ModuleUpdaterSplashState {
|
|
readonly status: ModuleUpdaterStatus;
|
|
readonly current: number | null;
|
|
readonly total: number | null;
|
|
readonly progress: number | null;
|
|
readonly seconds: number | null;
|
|
readonly moduleName: string | null;
|
|
readonly detail: string | null;
|
|
readonly receivedBytes: number | null;
|
|
readonly totalBytes: number | null;
|
|
readonly bytesPerSecond: number | null;
|
|
readonly stalled: boolean;
|
|
}
|
|
|
|
export interface ModuleUpdaterDiagnostics {
|
|
readonly state: ModuleUpdaterSplashState;
|
|
readonly packageOrigin: string;
|
|
readonly lastError: string | null;
|
|
readonly lastErrorAt: number | null;
|
|
}
|
|
|
|
interface ModuleUpdaterReport {
|
|
readonly type: ModuleUpdaterReportType;
|
|
readonly module: string | null;
|
|
readonly message: string;
|
|
readonly sampleRate: number;
|
|
readonly error: unknown;
|
|
}
|
|
|
|
export type ModuleUpdaterOutcome =
|
|
| {
|
|
readonly status: typeof ModuleUpdaterStatus.LAUNCHING;
|
|
readonly committed: Readonly<Record<string, string>>;
|
|
readonly rolledBack: boolean;
|
|
readonly belowFloor: ReadonlyArray<string>;
|
|
readonly launchAttempt: ModuleLaunchAttempt;
|
|
}
|
|
| {
|
|
readonly status: typeof ModuleUpdaterStatus.UNREACHABLE_LAUNCH;
|
|
readonly committed: Readonly<Record<string, string>>;
|
|
readonly launchAttempt: ModuleLaunchAttempt;
|
|
}
|
|
| {
|
|
readonly status: typeof ModuleUpdaterStatus.BLOCKED_UPDATE_REQUIRED;
|
|
readonly reason: ModuleUpdaterBlockReason;
|
|
readonly modules: ReadonlyArray<string>;
|
|
readonly message: string;
|
|
readonly updateServerUnreachable: boolean;
|
|
}
|
|
| {
|
|
readonly status: typeof ModuleUpdaterStatus.BLOCKED_SHELL_UPDATE;
|
|
readonly latestVersion: string;
|
|
readonly minimumVersion: string;
|
|
};
|
|
|
|
class ModuleUpdaterStorageFullError extends Error {
|
|
public constructor(message: string, options?: ErrorOptions) {
|
|
super(message, options);
|
|
this.name = 'ModuleUpdaterStorageFullError';
|
|
}
|
|
}
|
|
|
|
function hasErrorCode(error: unknown, codes: ReadonlySet<string>): boolean {
|
|
let cursor: unknown = error;
|
|
for (let depth = 0; depth < CAUSE_CHAIN_LIMIT && cursor != null; depth += 1) {
|
|
const code = (cursor as {code?: unknown}).code;
|
|
if (typeof code === 'string' && codes.has(code)) {
|
|
return true;
|
|
}
|
|
cursor = (cursor as {cause?: unknown}).cause;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isStorageFullError(error: unknown): boolean {
|
|
return hasErrorCode(error, STORAGE_FULL_CODES);
|
|
}
|
|
|
|
function isUpdateServerUnreachable(error: unknown): boolean {
|
|
let cursor: unknown = error;
|
|
for (let depth = 0; depth < CAUSE_CHAIN_LIMIT && cursor != null; depth += 1) {
|
|
if (cursor instanceof ModuleManifestFetchError || cursor instanceof ModulePackageFetchError) {
|
|
return isTransientServerStatus(cursor.status);
|
|
}
|
|
cursor = (cursor as {cause?: unknown}).cause;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function parseBundledRendererVersion(source: string | null): ModuleVersion | null {
|
|
if (source == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
return parseModuleVersion(source, 'bundled renderer version');
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function defaultSleep(ms: number): Promise<void> {
|
|
return new Promise((resolve) => {
|
|
setTimeout(resolve, ms);
|
|
});
|
|
}
|
|
|
|
class ModuleUpdaterBackoff {
|
|
private readonly random: () => number;
|
|
private attempt = 0;
|
|
private ceiling = false;
|
|
|
|
public constructor(random: () => number) {
|
|
this.random = random;
|
|
}
|
|
|
|
public get reachedCeiling(): boolean {
|
|
return this.ceiling;
|
|
}
|
|
|
|
public fail(): number {
|
|
const exponential = MODULE_UPDATER_BACKOFF_BASE_MS * 2 ** this.attempt;
|
|
this.attempt += 1;
|
|
if (exponential >= MODULE_UPDATER_BACKOFF_CAP_MS) {
|
|
this.ceiling = true;
|
|
}
|
|
return jitteredExponentialDelay(
|
|
MODULE_UPDATER_BACKOFF_BASE_MS,
|
|
MODULE_UPDATER_BACKOFF_CAP_MS,
|
|
this.attempt - 1,
|
|
this.random,
|
|
);
|
|
}
|
|
|
|
public reset(): void {
|
|
this.attempt = 0;
|
|
this.ceiling = false;
|
|
}
|
|
}
|
|
|
|
interface ModulePlanResult {
|
|
readonly desired: Readonly<Record<string, string>>;
|
|
readonly installed: ReadonlyArray<string>;
|
|
readonly blocked: ReadonlyArray<string>;
|
|
readonly blockedError: unknown;
|
|
}
|
|
|
|
const ModuleManifestObservationMode = Object.freeze({
|
|
READ_ONLY: 'read-only',
|
|
RECORD_FETCH: 'record-fetch',
|
|
} as const);
|
|
|
|
type ModuleManifestObservationMode = (typeof ModuleManifestObservationMode)[keyof typeof ModuleManifestObservationMode];
|
|
|
|
interface ModuleUpdaterOptions {
|
|
readonly store: ModuleStore;
|
|
readonly shellVersion: string;
|
|
readonly releaseChannel?: string;
|
|
readonly platform?: string;
|
|
readonly arch?: NodeJS.Architecture;
|
|
readonly packageOrigin?: string;
|
|
readonly hasOfflineRenderer?: boolean;
|
|
readonly bundledRendererVersion?: string | null;
|
|
readonly preferUnversionedBundle?: boolean;
|
|
readonly forceStartupUpdate?: boolean;
|
|
readonly moduleUpdatesDisabled?: boolean;
|
|
readonly moduleUpdatesDisabledBySetting?: boolean;
|
|
readonly selfUpdateShellFirst?: (latestVersion: string) => Promise<{readonly reason: string}>;
|
|
readonly onState?: (state: ModuleUpdaterSplashState) => void;
|
|
readonly report?: (report: ModuleUpdaterReport) => void;
|
|
readonly fetch: typeof globalThis.fetch;
|
|
readonly sleep?: (ms: number) => Promise<void>;
|
|
readonly random?: () => number;
|
|
readonly now?: () => number;
|
|
}
|
|
|
|
function isRejectedManifestError(error: unknown): boolean {
|
|
return error instanceof ModuleManifestRollbackError || error instanceof ModuleManifestEquivocationError;
|
|
}
|
|
|
|
export class ModuleUpdater {
|
|
public readonly store: ModuleStore;
|
|
private readonly platform: string;
|
|
private readonly shellVersion: ModuleVersion;
|
|
private readonly hasOfflineRenderer: boolean;
|
|
private readonly forceStartupUpdate: boolean;
|
|
private readonly moduleUpdatesDisabled: boolean;
|
|
private readonly moduleUpdatesDisabledBySetting: boolean;
|
|
private readonly selfUpdateShellFirst: ((latestVersion: string) => Promise<{readonly reason: string}>) | null;
|
|
private readonly shellFirstAttempts = new Map<string, {readonly reason: string} | null>();
|
|
private readonly manifestFeed: ModuleManifestFeedIdentity;
|
|
private readonly manifestRepository: ModuleManifestRepository;
|
|
private readonly planner: ModuleUpdatePlanner;
|
|
private readonly packageInstaller: ModulePackageInstaller;
|
|
private readonly onState: (state: ModuleUpdaterSplashState) => void;
|
|
private readonly reporter: (report: ModuleUpdaterReport) => void;
|
|
private readonly sleep: (ms: number) => Promise<void>;
|
|
private readonly random: () => number;
|
|
private readonly now: () => number;
|
|
private lastState: ModuleUpdaterSplashState;
|
|
private readonly packageOrigin: string;
|
|
private readonly downloadRate = new ModuleDownloadRate();
|
|
private downloadProgressed = false;
|
|
private lastError: string | null = null;
|
|
private lastErrorAt: number | null = null;
|
|
private ensureBlockedUntil = 0;
|
|
private readonly startupUpdateEnforced: boolean;
|
|
private manifestObservationTail: Promise<void> = Promise.resolve();
|
|
private recordedManifestSha256: string | null = null;
|
|
private lastAccepted: {readonly document: ModuleManifestDocument; readonly metadataVersion: number} | null = null;
|
|
|
|
public constructor(options: ModuleUpdaterOptions) {
|
|
this.store = options.store;
|
|
this.shellVersion = parseModuleVersion(options.shellVersion, 'desktop shell version');
|
|
this.hasOfflineRenderer = options.hasOfflineRenderer ?? false;
|
|
this.forceStartupUpdate = options.forceStartupUpdate ?? false;
|
|
this.moduleUpdatesDisabled = options.moduleUpdatesDisabled ?? false;
|
|
this.moduleUpdatesDisabledBySetting = options.moduleUpdatesDisabledBySetting ?? false;
|
|
this.selfUpdateShellFirst = options.selfUpdateShellFirst ?? null;
|
|
const releaseChannel = options.releaseChannel ?? BUILD_CHANNEL;
|
|
this.platform = options.platform ?? process.platform;
|
|
const arch = resolveDesktopModuleArchitecture(options.arch ?? process.arch);
|
|
this.manifestFeed = {releaseChannel, platform: this.platform, arch};
|
|
const packageOrigin = (options.packageOrigin ?? resolveDesktopPackageOrigin()).replace(/\/+$/u, '');
|
|
this.packageOrigin = packageOrigin;
|
|
this.planner = new ModuleUpdatePlanner(
|
|
this.store,
|
|
this.shellVersion,
|
|
this.hasOfflineRenderer,
|
|
parseBundledRendererVersion(options.bundledRendererVersion ?? null),
|
|
options.preferUnversionedBundle ?? false,
|
|
);
|
|
this.onState = options.onState ?? (() => {});
|
|
this.reporter = options.report ?? (() => {});
|
|
this.sleep = options.sleep ?? defaultSleep;
|
|
this.random = options.random ?? Math.random;
|
|
this.now = options.now ?? Date.now;
|
|
this.manifestRepository = new ModuleManifestRepository({
|
|
store: this.store,
|
|
target: {releaseChannel, platform: this.platform, arch},
|
|
packageOrigin,
|
|
fetch: options.fetch,
|
|
now: this.now,
|
|
onResponseCancellationError: (message, error) => {
|
|
this.report({type: ModuleUpdaterReportType.NETWORK_ERROR, message, error});
|
|
},
|
|
});
|
|
this.packageInstaller = new ModulePackageInstaller({
|
|
store: this.store,
|
|
packageOrigin,
|
|
fetch: options.fetch,
|
|
now: () => this.now(),
|
|
onProgress: (progress) => {
|
|
switch (progress.phase) {
|
|
case ModulePackageInstallPhase.DOWNLOADING:
|
|
this.recordDownloadProgress(progress.receivedBytes);
|
|
this.emit(ModuleUpdaterStatus.DOWNLOADING, {
|
|
...progress,
|
|
bytesPerSecond: this.downloadRate.sample(progress.receivedBytes, this.now()) ?? undefined,
|
|
});
|
|
break;
|
|
case ModulePackageInstallPhase.INSTALLING:
|
|
this.emit(ModuleUpdaterStatus.INSTALLING, progress);
|
|
break;
|
|
}
|
|
},
|
|
report: (report) => this.handlePackageInstallerReport(report),
|
|
});
|
|
this.startupUpdateEnforced = this.platform !== 'linux';
|
|
this.lastState = {
|
|
status: ModuleUpdaterStatus.CHECKING,
|
|
current: null,
|
|
total: null,
|
|
progress: null,
|
|
seconds: null,
|
|
moduleName: null,
|
|
detail: null,
|
|
receivedBytes: null,
|
|
totalBytes: null,
|
|
bytesPerSecond: null,
|
|
stalled: false,
|
|
};
|
|
}
|
|
|
|
public diagnostics(): ModuleUpdaterDiagnostics {
|
|
return {
|
|
state: this.lastState,
|
|
packageOrigin: this.packageOrigin,
|
|
lastError: this.lastError,
|
|
lastErrorAt: this.lastErrorAt,
|
|
};
|
|
}
|
|
|
|
private recordDownloadProgress(receivedBytes: number): void {
|
|
const previous = this.lastState.status === ModuleUpdaterStatus.DOWNLOADING ? this.lastState.receivedBytes : null;
|
|
if (previous != null && receivedBytes > previous) {
|
|
this.downloadProgressed = true;
|
|
}
|
|
}
|
|
|
|
public getLastState(): ModuleUpdaterSplashState {
|
|
return this.lastState;
|
|
}
|
|
|
|
public async run(): Promise<ModuleUpdaterOutcome> {
|
|
let attempt = await this.store.beginBootAttempt({bundled: this.planner.bundledModules()});
|
|
const retiredRenderer = await this.retireRendererCoveredByBundle();
|
|
const retiredMissing = await this.retireUninstalledModules();
|
|
const retiredIncompatible = await this.retireIncompatibleModules();
|
|
if (retiredRenderer || retiredMissing || retiredIncompatible) {
|
|
attempt = {...attempt, committed: this.store.getCommitted()};
|
|
}
|
|
if (attempt.rolledBack) {
|
|
this.report({
|
|
type: ModuleUpdaterReportType.ROLLBACK,
|
|
message: `reverted to the previous module set after ${MODULE_BOOT_ATTEMPT_ROLLBACK_THRESHOLD} launches without a ready window`,
|
|
});
|
|
const reverted = await this.launchRevertedSetBypassingFloor(attempt.committed);
|
|
if (reverted != null) {
|
|
return reverted;
|
|
}
|
|
}
|
|
if (this.moduleUpdatesDisabled || this.moduleUpdatesDisabledBySetting) {
|
|
const decision = await this.planner.evaluateUnreachableLaunch(this.startupUpdateEnforced);
|
|
if (decision.kind === ModuleUnreachableLaunchDecision.LAUNCH) {
|
|
return await this.launchUnreachable();
|
|
}
|
|
if (this.moduleUpdatesDisabled) {
|
|
return this.blockUpdateRequired(decision.reason, [], 'module updates are disabled', {
|
|
updateServerUnreachable: true,
|
|
});
|
|
}
|
|
}
|
|
if (this.platform === 'linux' && !(await this.startupUpdateRequired())) {
|
|
return await this.launchIfAtFloor();
|
|
}
|
|
const backoff = new ModuleUpdaterBackoff(this.random);
|
|
for (;;) {
|
|
this.emit(ModuleUpdaterStatus.CHECKING);
|
|
this.downloadRate.reset();
|
|
this.downloadProgressed = false;
|
|
let fetched = false;
|
|
try {
|
|
const document = await this.manifestRepository.fetchLatest();
|
|
fetched = true;
|
|
const manifest = await this.acceptManifest(document);
|
|
if (!(await this.startupUpdateRequired())) {
|
|
return await this.launchIfAtFloor();
|
|
}
|
|
const shellFirst = await this.updateShellFirst(manifest);
|
|
if (
|
|
this.startupUpdateEnforced &&
|
|
this.planner.shellUpdateRequired(manifest) &&
|
|
shellFirst?.reason !== 'no-update'
|
|
) {
|
|
this.emit(ModuleUpdaterStatus.BLOCKED_SHELL_UPDATE);
|
|
return {
|
|
status: ModuleUpdaterStatus.BLOCKED_SHELL_UPDATE,
|
|
latestVersion: manifest.shell.latestVersion.source,
|
|
minimumVersion: manifest.shell.minimumVersion.source,
|
|
};
|
|
}
|
|
const plan = await this.planner.plan(manifest);
|
|
if (plan.items.length === 0) {
|
|
await this.commitIfChanged(plan.base);
|
|
return await this.launchIfAtFloor();
|
|
}
|
|
const executed = await this.execute(plan);
|
|
if (executed.blocked.length > 0) {
|
|
return this.blockUpdateRequired(
|
|
ModuleUpdaterBlockReason.REQUIRED_MODULE_UNAVAILABLE,
|
|
executed.blocked,
|
|
`required module ${executed.blocked.join(', ')} could not be installed: ${describeErrorChain(executed.blockedError)}`,
|
|
{error: executed.blockedError},
|
|
);
|
|
}
|
|
if (executed.installed.length > 0) {
|
|
this.emit(ModuleUpdaterStatus.VERIFYING, {current: plan.items.length, total: plan.items.length});
|
|
}
|
|
await this.commitIfChanged(executed.desired);
|
|
if (executed.installed.length === 0) {
|
|
return await this.launchIfAtFloor();
|
|
}
|
|
backoff.reset();
|
|
} catch (error) {
|
|
this.reportFailure(error);
|
|
this.lastError = describeErrorChain(error);
|
|
this.lastErrorAt = this.now();
|
|
const detail = isStorageFullError(error) ? 'Not enough disk space to install the update' : null;
|
|
const updateServerUnreachable = !isRejectedManifestError(error) && isUpdateServerUnreachable(error);
|
|
if (this.downloadProgressed) {
|
|
backoff.reset();
|
|
}
|
|
const delayMs = backoff.fail();
|
|
const exhausted =
|
|
backoff.reachedCeiling ||
|
|
error instanceof ModuleManifestEquivocationError ||
|
|
(await this.forcedButLaunchable());
|
|
if (exhausted || !fetched) {
|
|
const decision = await this.planner.evaluateUnreachableLaunch(this.startupUpdateEnforced);
|
|
if (decision.kind === ModuleUnreachableLaunchDecision.LAUNCH) {
|
|
return await this.launchUnreachable();
|
|
}
|
|
if (exhausted) {
|
|
return this.blockUpdateRequired(decision.reason, [], describeErrorChain(error), {
|
|
detail,
|
|
error,
|
|
updateServerUnreachable,
|
|
});
|
|
}
|
|
}
|
|
const stalled = isModulePackageStall(error);
|
|
const position = stalled && this.lastState.status === ModuleUpdaterStatus.DOWNLOADING ? this.lastState : null;
|
|
this.emit(ModuleUpdaterStatus.RETRY_WAIT, {
|
|
seconds: Math.max(1, Math.round(delayMs / 1000)),
|
|
detail,
|
|
stalled,
|
|
current: position?.current ?? undefined,
|
|
total: position?.total ?? undefined,
|
|
progress: position?.progress ?? undefined,
|
|
moduleName: position?.moduleName ?? undefined,
|
|
receivedBytes: position?.receivedBytes ?? undefined,
|
|
totalBytes: position?.totalBytes ?? undefined,
|
|
});
|
|
await this.sleep(delayMs);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async ensureModule(moduleName: string): Promise<DesktopModuleEnsureResult> {
|
|
if (this.ensureBlockedUntil > this.now()) {
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.UNAVAILABLE};
|
|
}
|
|
let manifest: DesktopModuleUpdateManifest;
|
|
try {
|
|
manifest = await this.resolveManifestForEnsure();
|
|
} catch (error) {
|
|
this.ensureBlockedUntil = this.now() + MODULE_ENSURE_MANIFEST_BACKOFF_MS;
|
|
this.reportFailure(error);
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.UNAVAILABLE};
|
|
}
|
|
const committed = this.store.getCommitted()[moduleName];
|
|
if (committed != null && (await this.planner.isInstalled(moduleName, committed))) {
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.ALREADY_INSTALLED};
|
|
}
|
|
const entry = this.planner.compatibleEntry(manifest, moduleName);
|
|
if (
|
|
entry == null ||
|
|
(this.planner.isRendererAssetModule(moduleName) && !this.planner.rendererFollowsFeed(manifest))
|
|
) {
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.UNAVAILABLE};
|
|
}
|
|
if (this.store.isRejected(moduleName, entry.sha256)) {
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.UNAVAILABLE};
|
|
}
|
|
const item: ModulePlanItem = {module: moduleName, entry, requirement: ModulePlanItemRequirement.OPTIONAL};
|
|
try {
|
|
await this.packageInstaller.install(item, 1, 1);
|
|
} catch (error) {
|
|
if (isStorageFullError(error) || !isDeterministicPackageFailure(error)) {
|
|
throw error;
|
|
}
|
|
this.report({
|
|
type: ModuleUpdaterReportType.PACKAGE_MISSING,
|
|
module: moduleName,
|
|
message: errorMessage(error),
|
|
error,
|
|
});
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.UNAVAILABLE};
|
|
}
|
|
await this.store.mergeCommitted({[moduleName]: entry.sha256});
|
|
return {module: moduleName, status: DesktopModuleEnsureStatus.INSTALLED};
|
|
}
|
|
|
|
private async retireRendererCoveredByBundle(): Promise<boolean> {
|
|
const stale = await this.planner.staleRendererModule();
|
|
if (stale == null) {
|
|
return false;
|
|
}
|
|
if (!(await this.store.retireModule(DESKTOP_RENDERER_MODULE_NAME))) {
|
|
return false;
|
|
}
|
|
this.report({
|
|
type: ModuleUpdaterReportType.BUNDLED_RENDERER_PREFERRED,
|
|
module: DESKTOP_RENDERER_MODULE_NAME,
|
|
message: `retired installed renderer ${stale} because the renderer bundled with this shell is at least as new`,
|
|
});
|
|
return true;
|
|
}
|
|
|
|
private async retireUninstalledModules(): Promise<boolean> {
|
|
let retired = false;
|
|
for (const moduleName of await this.planner.uninstalledCommittedModules()) {
|
|
if (await this.store.retireModule(moduleName)) {
|
|
retired = true;
|
|
this.report({
|
|
type: ModuleUpdaterReportType.PACKAGE_MISSING,
|
|
module: moduleName,
|
|
message: 'dropped a committed module whose files are gone, the bundled renderer does not need it to launch',
|
|
});
|
|
}
|
|
}
|
|
return retired;
|
|
}
|
|
|
|
private async retireIncompatibleModules(): Promise<boolean> {
|
|
const cached = await this.readCachedManifest();
|
|
const retired = await this.store.retireIncompatible((moduleName, sha256) =>
|
|
this.planner.isRunnable(moduleName, sha256, cached),
|
|
);
|
|
for (const moduleName of retired) {
|
|
this.report({
|
|
type: ModuleUpdaterReportType.SHELL_INCOMPATIBLE_RETIRED,
|
|
module: moduleName,
|
|
message: `retired module ${moduleName} because shell ${this.shellVersion.source} cannot run it`,
|
|
});
|
|
}
|
|
return retired.length > 0;
|
|
}
|
|
|
|
private async readCachedManifest(): Promise<DesktopModuleUpdateManifest | null> {
|
|
try {
|
|
const document = await this.manifestRepository.readCached();
|
|
return document == null ? null : this.manifestRepository.parse(document);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async resolveManifestForEnsure(): Promise<DesktopModuleUpdateManifest> {
|
|
return this.acceptManifest(await this.manifestRepository.resolveMemoizedDocument());
|
|
}
|
|
|
|
private async updateShellFirst(manifest: DesktopModuleUpdateManifest): Promise<{readonly reason: string} | null> {
|
|
const latestVersion = manifest.shell.latestVersion.source;
|
|
if (
|
|
this.selfUpdateShellFirst == null ||
|
|
compareModuleVersions(manifest.shell.latestVersion, this.shellVersion) <= 0
|
|
) {
|
|
return null;
|
|
}
|
|
if (this.shellFirstAttempts.has(latestVersion)) {
|
|
return this.shellFirstAttempts.get(latestVersion) ?? null;
|
|
}
|
|
this.shellFirstAttempts.set(latestVersion, null);
|
|
const result = await this.selfUpdateShellFirst(latestVersion);
|
|
this.shellFirstAttempts.set(latestVersion, result);
|
|
this.emit(ModuleUpdaterStatus.CHECKING);
|
|
return result;
|
|
}
|
|
|
|
public async checkForUpdate(): Promise<DesktopUpdateProbe> {
|
|
const [manifest, feedLatest] = await Promise.all([
|
|
this.fetchFreshManifest(ModuleManifestObservationMode.READ_ONLY),
|
|
this.manifestRepository.fetchShellLatestVersion().catch((error: unknown) => {
|
|
this.reportFailure(error);
|
|
return null;
|
|
}),
|
|
]);
|
|
const shellLatest =
|
|
feedLatest != null && compareModuleVersions(feedLatest, manifest.shell.latestVersion) > 0
|
|
? feedLatest
|
|
: manifest.shell.latestVersion;
|
|
const shellLatestVersion = shellLatest.source;
|
|
const shellNewer = compareModuleVersions(shellLatest, this.shellVersion) > 0;
|
|
return {
|
|
shellLatestVersion,
|
|
shellNewer,
|
|
modulesChanged: (await this.collectPendingItems(manifest, this.planner)).length > 0,
|
|
};
|
|
}
|
|
|
|
public async installPending(): Promise<ModuleLaunchAttempt | null> {
|
|
this.emit(ModuleUpdaterStatus.CHECKING);
|
|
this.downloadRate.reset();
|
|
const manifest = await this.fetchFreshManifest(ModuleManifestObservationMode.RECORD_FETCH);
|
|
const items = await this.collectPendingItems(manifest, this.planner);
|
|
const {installed, unresolved} = await this.installItems(items);
|
|
if (Object.keys(installed).length > 0) {
|
|
this.emit(ModuleUpdaterStatus.VERIFYING, {current: items.length, total: items.length});
|
|
}
|
|
return await this.store.activateMergedForRendererReload(installed, unresolved);
|
|
}
|
|
|
|
private async fetchFreshManifest(mode: ModuleManifestObservationMode): Promise<DesktopModuleUpdateManifest> {
|
|
this.manifestRepository.clearMemo();
|
|
return await this.acceptManifest(await this.manifestRepository.fetchLatest(), mode);
|
|
}
|
|
|
|
private async acceptManifest(
|
|
document: ModuleManifestDocument,
|
|
mode: ModuleManifestObservationMode = ModuleManifestObservationMode.RECORD_FETCH,
|
|
): Promise<DesktopModuleUpdateManifest> {
|
|
try {
|
|
return await this.observeManifest(document, mode);
|
|
} catch (error) {
|
|
if (!(error instanceof ModuleManifestRollbackError)) {
|
|
throw error;
|
|
}
|
|
const fallback = this.lastAccepted?.document ?? (await this.manifestRepository.readCached());
|
|
if (fallback == null || fallback === document) {
|
|
throw error;
|
|
}
|
|
return await this.observeManifest(fallback, mode);
|
|
}
|
|
}
|
|
|
|
private async collectPendingItems(
|
|
manifest: DesktopModuleUpdateManifest,
|
|
planner: ModuleUpdatePlanner,
|
|
): Promise<Array<ModulePlanItem>> {
|
|
const committed = this.store.getCommitted();
|
|
const names = new Set<string>([...Object.keys(committed), ...manifest.requiredModules]);
|
|
const wanted: Array<ModulePlanItem> = [];
|
|
for (const moduleName of Array.from(names).sort()) {
|
|
const entry = manifest.modules[moduleName];
|
|
if (entry == null || planner.skipsFeedEntry(manifest, moduleName)) {
|
|
continue;
|
|
}
|
|
if (committed[moduleName] === entry.sha256 && (await planner.isInstalled(moduleName, entry.sha256))) {
|
|
continue;
|
|
}
|
|
if (this.store.isRejected(moduleName, entry.sha256)) {
|
|
continue;
|
|
}
|
|
wanted.push({module: moduleName, entry, requirement: ModulePlanItemRequirement.OPTIONAL});
|
|
}
|
|
return wanted;
|
|
}
|
|
|
|
private async installItems(
|
|
items: ReadonlyArray<ModulePlanItem>,
|
|
): Promise<{readonly installed: Readonly<Record<string, string>>; readonly unresolved: ReadonlySet<string>}> {
|
|
const committed = this.store.getCommitted();
|
|
const installed: Record<string, string> = {};
|
|
const unresolved = new Set<string>();
|
|
for (let index = 0; index < items.length; index += 1) {
|
|
const item = items[index];
|
|
try {
|
|
await this.packageInstaller.install(item, index + 1, items.length);
|
|
} catch (error) {
|
|
if (isStorageFullError(error) || !isDeterministicPackageFailure(error)) {
|
|
throw error;
|
|
}
|
|
this.report({
|
|
type: ModuleUpdaterReportType.PACKAGE_MISSING,
|
|
module: item.module,
|
|
message: errorMessage(error),
|
|
error,
|
|
});
|
|
const committedSha = committed[item.module];
|
|
if (committedSha === undefined || !(await this.planner.isInstalled(item.module, committedSha))) {
|
|
unresolved.add(item.module);
|
|
}
|
|
continue;
|
|
}
|
|
installed[item.module] = item.entry.sha256;
|
|
}
|
|
return {installed, unresolved};
|
|
}
|
|
|
|
public async selectServedModules(modules: Readonly<Record<string, string>>): Promise<ServedModuleSelection> {
|
|
return await this.planner.selectServedModules(modules);
|
|
}
|
|
|
|
public async revertLaunch(attempt: ModuleLaunchAttempt): Promise<Readonly<Record<string, string>> | null> {
|
|
const reverted = await this.store.revertLaunchAttempt(attempt, this.planner.bundledModules());
|
|
if (reverted != null) {
|
|
this.report({
|
|
type: ModuleUpdaterReportType.ROLLBACK,
|
|
message: 'reverted an in place module update whose renderer never confirmed it started',
|
|
});
|
|
}
|
|
return reverted;
|
|
}
|
|
|
|
public async markLaunchSucceeded(attempt: ModuleLaunchAttempt): Promise<void> {
|
|
if (!(await this.store.markLaunchAttemptSucceeded(attempt))) {
|
|
return;
|
|
}
|
|
await this.store.collectGarbage({now: this.now()});
|
|
}
|
|
|
|
private async launchIfAtFloor(): Promise<ModuleUpdaterOutcome> {
|
|
const below = await this.planner.modulesBelowFloor(this.startupUpdateEnforced);
|
|
if (below.length > 0) {
|
|
return this.blockUpdateRequired(
|
|
ModuleUpdaterBlockReason.BELOW_FLOOR,
|
|
below,
|
|
`the installed set is below the required floor for ${below.join(', ')}`,
|
|
);
|
|
}
|
|
if (!this.planner.hasSomethingToRender(this.store.getCommitted())) {
|
|
return this.blockUpdateRequired(
|
|
ModuleUpdaterBlockReason.NOTHING_INSTALLED,
|
|
[],
|
|
'no module is committed and this build carries no offline renderer',
|
|
);
|
|
}
|
|
await this.store.recordShellVersionConverged();
|
|
const launchAttempt = await this.store.recordLaunchAttempt();
|
|
this.emit(ModuleUpdaterStatus.LAUNCHING);
|
|
return {
|
|
status: ModuleUpdaterStatus.LAUNCHING,
|
|
committed: this.store.getCommitted(),
|
|
rolledBack: false,
|
|
belowFloor: [],
|
|
launchAttempt,
|
|
};
|
|
}
|
|
|
|
private async launchUnreachable(): Promise<ModuleUpdaterOutcome> {
|
|
const launchAttempt = await this.store.recordLaunchAttempt();
|
|
this.emit(ModuleUpdaterStatus.UNREACHABLE_LAUNCH);
|
|
return {
|
|
status: ModuleUpdaterStatus.UNREACHABLE_LAUNCH,
|
|
committed: this.store.getCommitted(),
|
|
launchAttempt,
|
|
};
|
|
}
|
|
|
|
private async launchRevertedSetBypassingFloor(
|
|
committed: Readonly<Record<string, string>>,
|
|
): Promise<ModuleUpdaterOutcome | null> {
|
|
const names = Object.keys(committed);
|
|
if (names.length === 0) {
|
|
return null;
|
|
}
|
|
for (const moduleName of names) {
|
|
if (!(await this.planner.isInstalled(moduleName, committed[moduleName]))) {
|
|
return null;
|
|
}
|
|
}
|
|
const belowFloor = await this.planner.modulesBelowFloor(this.startupUpdateEnforced);
|
|
if (belowFloor.length > 0) {
|
|
this.report({
|
|
type: ModuleUpdaterReportType.ROLLBACK_FLOOR_BYPASS,
|
|
message: `launching the reverted set below the persisted floor for ${belowFloor.join(', ')}, because recovering a bricked install outranks enforcing the forced update`,
|
|
});
|
|
}
|
|
const launchAttempt = await this.store.recordLaunchAttempt();
|
|
this.emit(ModuleUpdaterStatus.LAUNCHING);
|
|
return {
|
|
status: ModuleUpdaterStatus.LAUNCHING,
|
|
committed,
|
|
rolledBack: true,
|
|
belowFloor,
|
|
launchAttempt,
|
|
};
|
|
}
|
|
|
|
private blockUpdateRequired(
|
|
reason: ModuleUpdaterBlockReason,
|
|
modules: ReadonlyArray<string>,
|
|
message: string,
|
|
{
|
|
detail = null,
|
|
error = null,
|
|
updateServerUnreachable = false,
|
|
}: {readonly detail?: string | null; readonly error?: unknown; readonly updateServerUnreachable?: boolean} = {},
|
|
): ModuleUpdaterOutcome {
|
|
this.report({type: ModuleUpdaterReportType.BLOCKED, message: `${reason}: ${message}`, error});
|
|
this.emit(ModuleUpdaterStatus.BLOCKED_UPDATE_REQUIRED, {detail});
|
|
return {
|
|
status: ModuleUpdaterStatus.BLOCKED_UPDATE_REQUIRED,
|
|
reason,
|
|
modules,
|
|
message,
|
|
updateServerUnreachable,
|
|
};
|
|
}
|
|
|
|
private observeManifest(
|
|
document: ModuleManifestDocument,
|
|
mode: ModuleManifestObservationMode = ModuleManifestObservationMode.RECORD_FETCH,
|
|
): Promise<DesktopModuleUpdateManifest> {
|
|
const observe = async (): Promise<DesktopModuleUpdateManifest> => {
|
|
const manifest = this.manifestRepository.parse(document);
|
|
const accepted = this.lastAccepted;
|
|
if (accepted != null && manifest.metadataVersion < accepted.metadataVersion) {
|
|
throw new ModuleManifestRollbackError(this.manifestFeed, manifest.metadataVersion, accepted.metadataVersion);
|
|
}
|
|
const observation: ModuleManifestFeedObservation = {
|
|
feed: this.manifestFeed,
|
|
metadataVersion: manifest.metadataVersion,
|
|
manifestSha256: createHash('sha256').update(document.bytes).digest('hex'),
|
|
};
|
|
this.store.requireManifestFresh(observation);
|
|
await this.backfillShellRanges(manifest);
|
|
if (
|
|
mode === ModuleManifestObservationMode.RECORD_FETCH &&
|
|
this.recordedManifestSha256 !== observation.manifestSha256
|
|
) {
|
|
await this.persistManifest(document, manifest, observation);
|
|
this.recordedManifestSha256 = observation.manifestSha256;
|
|
}
|
|
this.lastAccepted = {document, metadataVersion: manifest.metadataVersion};
|
|
return manifest;
|
|
};
|
|
const observed = this.manifestObservationTail.then(observe, observe);
|
|
this.manifestObservationTail = observed.then(
|
|
() => undefined,
|
|
() => undefined,
|
|
);
|
|
return observed;
|
|
}
|
|
|
|
private async backfillShellRanges(manifest: DesktopModuleUpdateManifest): Promise<void> {
|
|
const ranges = [];
|
|
for (const [moduleName, sha256] of Object.entries(this.store.getCommitted())) {
|
|
const entry = manifest.modules[moduleName];
|
|
if (entry?.sha256 !== sha256) {
|
|
continue;
|
|
}
|
|
ranges.push({
|
|
module: moduleName,
|
|
sha256,
|
|
minimum: entry.minimumShellVersion?.source ?? null,
|
|
maximum: entry.maximumShellVersion?.source ?? null,
|
|
});
|
|
}
|
|
await this.store.recordShellRanges(ranges);
|
|
}
|
|
|
|
private async forcedButLaunchable(): Promise<boolean> {
|
|
return this.forceStartupUpdate && !this.startupUpdateEnforced && (await this.planner.canLaunchCommittedModules());
|
|
}
|
|
|
|
private async startupUpdateRequired(): Promise<boolean> {
|
|
return this.forceStartupUpdate || this.startupUpdateEnforced || !(await this.planner.canLaunchCommittedModules());
|
|
}
|
|
|
|
private async execute(plan: ModulePlan): Promise<ModulePlanResult> {
|
|
const desired: Record<string, string> = {...plan.base};
|
|
const installed: Array<string> = [];
|
|
const blocked: Array<string> = [];
|
|
let blockedError: unknown = null;
|
|
const total = plan.items.length;
|
|
for (let index = 0; index < total; index += 1) {
|
|
const item = plan.items[index];
|
|
try {
|
|
await this.packageInstaller.install(item, index + 1, total);
|
|
desired[item.module] = item.entry.sha256;
|
|
installed.push(item.module);
|
|
} catch (error) {
|
|
if (isStorageFullError(error)) {
|
|
this.report({
|
|
type: ModuleUpdaterReportType.STORAGE_ERROR,
|
|
module: item.module,
|
|
message: errorMessage(error),
|
|
error,
|
|
});
|
|
throw new ModuleUpdaterStorageFullError(`no space left to install ${item.module}`, {cause: error});
|
|
}
|
|
if (!isDeterministicPackageFailure(error)) {
|
|
throw error;
|
|
}
|
|
if (item.requirement === ModulePlanItemRequirement.REQUIRED) {
|
|
blocked.push(item.module);
|
|
blockedError = error;
|
|
break;
|
|
}
|
|
await this.planner.retainCommitted(desired, item.module);
|
|
}
|
|
}
|
|
return {desired, installed, blocked, blockedError};
|
|
}
|
|
|
|
private async persistManifest(
|
|
document: ModuleManifestDocument,
|
|
manifest: DesktopModuleUpdateManifest,
|
|
observation: ModuleManifestFeedObservation,
|
|
): Promise<void> {
|
|
const floor: Record<string, string> = {};
|
|
const advertised: Record<string, string> = {};
|
|
for (const [moduleName, entry] of Object.entries(manifest.modules)) {
|
|
advertised[moduleName] = entry.sha256;
|
|
}
|
|
if (this.startupUpdateEnforced) {
|
|
const enforced = this.store.getState().floor;
|
|
for (const moduleName of manifest.requiredModules) {
|
|
if (this.planner.bundleCoversModule(moduleName, manifest)) {
|
|
continue;
|
|
}
|
|
const sha256 = this.planner.compatibleEntry(manifest, moduleName)?.sha256 ?? enforced[moduleName];
|
|
if (sha256 != null) {
|
|
floor[moduleName] = sha256;
|
|
}
|
|
}
|
|
}
|
|
await this.manifestRepository.persist(document);
|
|
await this.store.recordManifestFetch({
|
|
etag: document.etag,
|
|
fetchedAt: new Date(this.now()).toISOString(),
|
|
manifest: observation,
|
|
floor,
|
|
advertised,
|
|
});
|
|
}
|
|
|
|
private async commitIfChanged(desired: Readonly<Record<string, string>>): Promise<void> {
|
|
if (sameModuleMap(this.store.getCommitted(), desired)) {
|
|
return;
|
|
}
|
|
await this.store.commit(desired);
|
|
}
|
|
|
|
private reportFailure(error: unknown): void {
|
|
if (error instanceof ModuleManifestRollbackError) {
|
|
this.report({type: ModuleUpdaterReportType.MANIFEST_ROLLBACK, message: error.message, error});
|
|
return;
|
|
}
|
|
if (error instanceof ModuleManifestEquivocationError) {
|
|
this.report({type: ModuleUpdaterReportType.MANIFEST_EQUIVOCATION, message: error.message, error});
|
|
return;
|
|
}
|
|
if (isStorageFullError(error)) {
|
|
this.report({type: ModuleUpdaterReportType.STORAGE_ERROR, message: errorMessage(error), error});
|
|
return;
|
|
}
|
|
this.report({type: ModuleUpdaterReportType.NETWORK_ERROR, message: errorMessage(error), error});
|
|
}
|
|
|
|
private handlePackageInstallerReport(report: ModulePackageInstallerReport): void {
|
|
switch (report.type) {
|
|
case ModulePackageInstallerReportType.HASH_MISMATCH:
|
|
this.report({...report, type: ModuleUpdaterReportType.PACKAGE_HASH_MISMATCH});
|
|
break;
|
|
case ModulePackageInstallerReportType.PACKAGE_MISSING:
|
|
this.report({...report, type: ModuleUpdaterReportType.PACKAGE_MISSING});
|
|
break;
|
|
case ModulePackageInstallerReportType.PACKAGE_REJECTED:
|
|
this.report({...report, type: ModuleUpdaterReportType.PACKAGE_REJECTED});
|
|
break;
|
|
case ModulePackageInstallerReportType.NETWORK_ERROR:
|
|
this.report({...report, type: ModuleUpdaterReportType.NETWORK_ERROR});
|
|
break;
|
|
}
|
|
}
|
|
|
|
private report({
|
|
type,
|
|
module: moduleName = null,
|
|
message,
|
|
error = null,
|
|
}: {
|
|
readonly type: ModuleUpdaterReportType;
|
|
readonly module?: string | null;
|
|
readonly message: string;
|
|
readonly error?: unknown;
|
|
}): void {
|
|
const sampleRate = MODULE_UPDATER_REPORT_SAMPLE_RATES[type];
|
|
if (sampleRate < 1 && this.random() >= sampleRate) {
|
|
return;
|
|
}
|
|
this.reporter({type, module: moduleName, message, sampleRate, error});
|
|
}
|
|
|
|
private emit(
|
|
status: ModuleUpdaterStatus,
|
|
patch: {
|
|
readonly current?: number;
|
|
readonly total?: number;
|
|
readonly progress?: number;
|
|
readonly seconds?: number;
|
|
readonly moduleName?: string;
|
|
readonly detail?: string | null;
|
|
readonly receivedBytes?: number;
|
|
readonly totalBytes?: number;
|
|
readonly bytesPerSecond?: number;
|
|
readonly stalled?: boolean;
|
|
} = {},
|
|
): void {
|
|
this.lastState = {
|
|
status,
|
|
current: patch.current ?? null,
|
|
total: patch.total ?? null,
|
|
progress: patch.progress ?? null,
|
|
seconds: patch.seconds ?? null,
|
|
moduleName: patch.moduleName ?? null,
|
|
detail: patch.detail ?? null,
|
|
receivedBytes: patch.receivedBytes ?? null,
|
|
totalBytes: patch.totalBytes ?? null,
|
|
bytesPerSecond: patch.bytesPerSecond ?? null,
|
|
stalled: patch.stalled === true,
|
|
};
|
|
this.onState(this.lastState);
|
|
}
|
|
}
|