277c691b2c
The Linux app now downloads the release archive to a temporary folder, verifies its checksum, extracts it beside the install folder, swaps the bundle in with two renames (keeping <install>.previous for rollback) and relaunches. A read-only install location is reported with how to fix it. The prompt and Settings button say "Install and restart".
189 lines
5.9 KiB
Dart
189 lines
5.9 KiB
Dart
import 'dart:io';
|
|
import 'dart:convert';
|
|
import 'dart:ffi';
|
|
|
|
import 'package:crypto/crypto.dart' as crypto;
|
|
|
|
import 'package:open_filex/open_filex.dart';
|
|
import 'package:package_info_plus/package_info_plus.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
|
|
import '../../core/session/server_session.dart';
|
|
import 'app_updates.dart';
|
|
import 'linux_self_update.dart';
|
|
|
|
bool get supported =>
|
|
Platform.isAndroid || Platform.isLinux || Platform.isMacOS;
|
|
String get nativePlatform => Platform.isMacOS
|
|
? 'macos'
|
|
: Platform.isLinux
|
|
? 'linux'
|
|
: 'android';
|
|
String get nativeArchitecture {
|
|
final abi = Abi.current().toString();
|
|
if (abi.endsWith('_arm64')) return 'arm64';
|
|
if (abi.endsWith('_x64')) return 'x64';
|
|
return 'unsupported';
|
|
}
|
|
|
|
Future<int?> installedVersionCode() async {
|
|
const embedded = int.fromEnvironment('PIPELINES_NATIVE_BUILD_CODE');
|
|
if (embedded > 0) return embedded;
|
|
final info = await PackageInfo.fromPlatform();
|
|
return int.tryParse(info.buildNumber);
|
|
}
|
|
|
|
Future<HttpClientResponse> _get(
|
|
HttpClient client,
|
|
Uri uri, [
|
|
Map<String, String> Function(Uri)? headers,
|
|
]) async {
|
|
final request = await client.getUrl(uri).timeout(const Duration(seconds: 15));
|
|
request.followRedirects = false;
|
|
// The updates sit behind the same web login the app signed in to.
|
|
(headers ?? ServerSession.headersFor)(uri).forEach(request.headers.set);
|
|
final response = await request.close().timeout(const Duration(seconds: 15));
|
|
if (response.statusCode == 401 || response.statusCode == 302) {
|
|
await response.drain<void>();
|
|
throw const HttpException('Sign in first (Settings → Sign in).');
|
|
}
|
|
if (response.statusCode != 200) {
|
|
await response.drain<void>();
|
|
throw HttpException('The server answered ${response.statusCode}.');
|
|
}
|
|
return response;
|
|
}
|
|
|
|
Future<AppUpdate> fetchLatest(Uri base) =>
|
|
fetchLatestScoped(base, ServerSession.headersFor);
|
|
|
|
Future<AppUpdate> fetchLatestScoped(
|
|
Uri base,
|
|
Map<String, String> Function(Uri) headers,
|
|
) async {
|
|
final platform = nativePlatform;
|
|
if (platform == 'linux' && nativeArchitecture != 'x64') {
|
|
throw const FormatException(
|
|
'No Linux build is available for this architecture.',
|
|
);
|
|
}
|
|
final feed = platform == 'android'
|
|
? base
|
|
: base.resolve(platform == 'linux' ? 'linux-x64/' : 'macos/');
|
|
final client = HttpClient()..connectionTimeout = const Duration(seconds: 10);
|
|
try {
|
|
final response = await _get(client, feed.resolve('version.json'), headers);
|
|
var bytes = 0;
|
|
final chunks = <int>[];
|
|
await for (final chunk in response.timeout(const Duration(seconds: 10))) {
|
|
bytes += chunk.length;
|
|
if (bytes > 65536) {
|
|
throw const FormatException('Update metadata is too large.');
|
|
}
|
|
chunks.addAll(chunk);
|
|
}
|
|
final update = AppUpdate.parse(
|
|
utf8.decode(chunks),
|
|
feed,
|
|
platform: platform,
|
|
architecture: nativeArchitecture,
|
|
installedSignature: platform == 'android'
|
|
? (await PackageInfo.fromPlatform()).buildSignature
|
|
: null,
|
|
);
|
|
if (update == null) {
|
|
throw const FormatException('No compatible build is offered.');
|
|
}
|
|
return update;
|
|
} finally {
|
|
client.close(force: true);
|
|
}
|
|
}
|
|
|
|
/// Downloads to a partial file and publishes it only after integrity checks.
|
|
Future<File> downloadUpdate(
|
|
AppUpdate update,
|
|
Directory dir, {
|
|
void Function(double progress)? onProgress,
|
|
}) async {
|
|
final client = HttpClient()..connectionTimeout = const Duration(seconds: 15);
|
|
final suffix = update.platform == 'android'
|
|
? 'apk'
|
|
: update.platform == 'macos'
|
|
? 'zip'
|
|
: 'tar.gz';
|
|
final file = File('${dir.path}/pipelines-${update.versionCode}.$suffix');
|
|
final partial = File('${file.path}.part');
|
|
try {
|
|
final response = await _get(client, update.apk, update.headersFor);
|
|
final total = response.contentLength;
|
|
final sink = partial.openWrite();
|
|
var received = 0;
|
|
try {
|
|
await for (final chunk in response.timeout(const Duration(seconds: 30))) {
|
|
sink.add(chunk);
|
|
received += chunk.length;
|
|
if (total > 0) onProgress?.call(received / total);
|
|
}
|
|
} finally {
|
|
await sink.close();
|
|
}
|
|
if (total >= 0 && received != total) {
|
|
throw const HttpException('The update download was incomplete.');
|
|
}
|
|
if (update.sha256.isNotEmpty) {
|
|
final digest = await crypto.sha256.bind(partial.openRead()).first;
|
|
if (digest.toString() != update.sha256.toLowerCase()) {
|
|
throw const FormatException(
|
|
'The downloaded update failed its integrity check.',
|
|
);
|
|
}
|
|
}
|
|
await partial.rename(file.path);
|
|
return file;
|
|
} finally {
|
|
client.close(force: true);
|
|
if (await partial.exists()) await partial.delete();
|
|
}
|
|
}
|
|
|
|
Future<void> downloadAndInstall(
|
|
AppUpdate update, {
|
|
void Function(double progress)? onProgress,
|
|
}) async {
|
|
if (Platform.isLinux) {
|
|
// Linux installs in place: download, verify, swap the bundle, relaunch.
|
|
final installer = LinuxSelfUpdate.current();
|
|
final problem = await installer.problem();
|
|
if (problem != null) throw FileSystemException(problem);
|
|
final file = await downloadUpdate(
|
|
update,
|
|
await getTemporaryDirectory(),
|
|
onProgress: onProgress,
|
|
);
|
|
final String executable;
|
|
try {
|
|
executable = await installer.install(
|
|
file,
|
|
versionCode: update.versionCode,
|
|
);
|
|
} finally {
|
|
if (await file.exists()) await file.delete();
|
|
}
|
|
await LinuxSelfUpdate.relaunch(executable);
|
|
}
|
|
final dir = Platform.isAndroid
|
|
? await getTemporaryDirectory()
|
|
: (await getDownloadsDirectory() ?? await getTemporaryDirectory());
|
|
final file = await downloadUpdate(update, dir, onProgress: onProgress);
|
|
final result = await OpenFilex.open(
|
|
file.path,
|
|
type: Platform.isAndroid ? 'application/vnd.android.package-archive' : null,
|
|
);
|
|
if (result.type != ResultType.done) {
|
|
throw HttpException(
|
|
'Could not open the downloaded update: ${result.message}',
|
|
);
|
|
}
|
|
}
|