Build Linux and macOS clients with platform update feeds

This commit is contained in:
2026-11-08 16:45:42 +00:00
parent b7f439a94f
commit 36f73bb89d
17 changed files with 913 additions and 9 deletions
+2
View File
@@ -28,6 +28,8 @@ cd pipelines
./install # server + CLI + web app, login autostart ./install # server + CLI + web app, login autostart
./install --web # rebuild only the web app after app changes ./install --web # rebuild only the web app after app changes
./install --apk # optional: Android app, offered to phones for update ./install --apk # optional: Android app, offered to phones for update
./install --linux # Linux x64 client archive, built in Docker
./install --macos --flutter /path/to/flutter # native macOS client archive
``` ```
Needs Go (version in `go.mod`), Node.js 18+, Python 3.9+, git, curl, a C Needs Go (version in `go.mod`), Node.js 18+, Python 3.9+, git, curl, a C
+7
View File
@@ -23,6 +23,13 @@ RUN mkdir -p /home/builder/.pub-cache \
COPY build.sh /usr/local/bin/pipelines-app-build COPY build.sh /usr/local/bin/pipelines-app-build
WORKDIR /tmp WORKDIR /tmp
FROM web AS linux
RUN apt-get update \
&& apt-get install -y --no-install-recommends clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-12-dev liblzma-dev \
&& rm -rf /var/lib/apt/lists/* \
&& flutter precache --linux \
&& chmod -R a+rwX /opt/flutter /home/builder
FROM web AS android FROM web AS android
ARG ANDROID_CMDLINE_TOOLS=13114758 ARG ANDROID_CMDLINE_TOOLS=13114758
RUN apt-get update \ RUN apt-get update \
+5
View File
@@ -8,6 +8,7 @@ rm -rf /tmp/work && mkdir -p /tmp/work
# A private copy: the host checkout's build outputs and machine paths stay out. # A private copy: the host checkout's build outputs and machine paths stay out.
(cd /src && tar --exclude=./build --exclude=./.dart_tool --exclude=./android/.gradle \ (cd /src && tar --exclude=./build --exclude=./.dart_tool --exclude=./android/.gradle \
--exclude=./android/local.properties --exclude=./android/app/.cxx --exclude=./ios/Pods \ --exclude=./android/local.properties --exclude=./android/app/.cxx --exclude=./ios/Pods \
--exclude=./macos/Pods --exclude=./macos/Flutter/ephemeral --exclude=./linux/flutter/ephemeral \
-cf - .) | tar -C /tmp/work -xf - -cf - .) | tar -C /tmp/work -xf -
cd /tmp/work cd /tmp/work
flutter pub get flutter pub get
@@ -31,6 +32,10 @@ PROPERTIES
flutter build apk --release "$@" flutter build apk --release "$@"
cp build/app/outputs/flutter-apk/app-release.apk /out/pipelines.apk cp build/app/outputs/flutter-apk/app-release.apk /out/pipelines.apk
;; ;;
linux)
flutter build linux --release "$@"
cp -a build/linux/x64/release/bundle/. /out/
;;
*) *)
echo "unknown build: $kind" >&2 echo "unknown build: $kind" >&2
exit 2 exit 2
+1
View File
@@ -0,0 +1 @@
flutter/ephemeral
+128
View File
@@ -0,0 +1,128 @@
# Project-level configuration.
cmake_minimum_required(VERSION 3.13)
project(runner LANGUAGES CXX)
# The name of the executable created for the application. Change this to change
# the on-disk name of your application.
set(BINARY_NAME "pipelines-app")
# The unique GTK application identifier for this application. See:
# https://wiki.gnome.org/HowDoI/ChooseApplicationID
set(APPLICATION_ID "com.pipelines.app")
# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake.
cmake_policy(SET CMP0063 NEW)
# Load bundled libraries from the lib/ directory relative to the binary.
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
# Root filesystem for cross-building.
if(FLUTTER_TARGET_PLATFORM_SYSROOT)
set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()
# Define build configuration options.
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE "Debug" CACHE
STRING "Flutter build mode" FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Profile" "Release")
endif()
# Compilation settings that should be applied to most targets.
#
# Be cautious about adding new options here, as plugins use this function by
# default. In most cases, you should add new options to specific targets instead
# of modifying this function.
function(APPLY_STANDARD_SETTINGS TARGET)
target_compile_features(${TARGET} PUBLIC cxx_std_14)
target_compile_options(${TARGET} PRIVATE -Wall -Werror)
target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
# Flutter library and tool build rules.
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
# Application build; see runner/CMakeLists.txt.
add_subdirectory("runner")
# Run the Flutter tool portions of the build. This must not be removed.
add_dependencies(${BINARY_NAME} flutter_assemble)
# Only the install-generated bundle's copy of the executable will launch
# correctly, since the resources must in the right relative locations. To avoid
# people trying to run the unbundled copy, put it in a subdirectory instead of
# the default top-level location.
set_target_properties(${BINARY_NAME}
PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)
# Generated plugin build rules, which manage building the plugins and adding
# them to the application.
include(flutter/generated_plugins.cmake)
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE)
endif()
# Start with a clean build bundle directory every time.
install(CODE "
file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
" COMPONENT Runtime)
set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
COMPONENT Runtime)
install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
COMPONENT Runtime)
install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
install(FILES "${bundled_library}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endforeach(bundled_library)
# Copy the native assets provided by the build.dart from all packages.
set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/")
install(DIRECTORY "${NATIVE_ASSETS_DIR}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
# Fully re-copy the assets directory on each build to avoid having stale files
# from a previous install.
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "
file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
" COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
# Install the AOT library on non-Debug builds only.
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endif()
+88
View File
@@ -0,0 +1,88 @@
# This file controls Flutter-level build steps. It should not be edited.
cmake_minimum_required(VERSION 3.10)
set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
# TODO: Move the rest of this into files in ephemeral. See
# https://github.com/flutter/flutter/issues/57146.
# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
# which isn't available in 3.10.
function(list_prepend LIST_NAME PREFIX)
set(NEW_LIST "")
foreach(element ${${LIST_NAME}})
list(APPEND NEW_LIST "${PREFIX}${element}")
endforeach(element)
set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
# === Flutter Library ===
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
list(APPEND FLUTTER_LIBRARY_HEADERS
"fl_basic_message_channel.h"
"fl_binary_codec.h"
"fl_binary_messenger.h"
"fl_dart_project.h"
"fl_engine.h"
"fl_json_message_codec.h"
"fl_json_method_codec.h"
"fl_message_codec.h"
"fl_method_call.h"
"fl_method_channel.h"
"fl_method_codec.h"
"fl_method_response.h"
"fl_plugin_registrar.h"
"fl_plugin_registry.h"
"fl_standard_message_codec.h"
"fl_standard_method_codec.h"
"fl_string_codec.h"
"fl_value.h"
"fl_view.h"
"flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
"${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
PkgConfig::GTK
PkgConfig::GLIB
PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
# === Flutter tool backend ===
# _phony_ is a non-existent file to force this command to run every time,
# since currently there's no way to get a full input/output list from the
# flutter tool.
add_custom_command(
OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
${CMAKE_CURRENT_BINARY_DIR}/_phony_
COMMAND ${CMAKE_COMMAND} -E env
${FLUTTER_TOOL_ENVIRONMENT}
"${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
VERBATIM
)
add_custom_target(flutter_assemble DEPENDS
"${FLUTTER_LIBRARY}"
${FLUTTER_LIBRARY_HEADERS}
)
+26
View File
@@ -0,0 +1,26 @@
cmake_minimum_required(VERSION 3.13)
project(runner LANGUAGES CXX)
# Define the application target. To change its name, change BINARY_NAME in the
# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer
# work.
#
# Any new source files that you add to the application should be added here.
add_executable(${BINARY_NAME}
"main.cc"
"my_application.cc"
"${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)
# Apply the standard set of build settings. This can be removed for applications
# that need different build settings.
apply_standard_settings(${BINARY_NAME})
# Add preprocessor definitions for the application ID.
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
# Add dependency libraries. Add any application-specific dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}")
+6
View File
@@ -0,0 +1,6 @@
#include "my_application.h"
int main(int argc, char** argv) {
g_autoptr(MyApplication) app = my_application_new();
return g_application_run(G_APPLICATION(app), argc, argv);
}
+148
View File
@@ -0,0 +1,148 @@
#include "my_application.h"
#include <flutter_linux/flutter_linux.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "flutter/generated_plugin_registrant.h"
struct _MyApplication {
GtkApplication parent_instance;
char** dart_entrypoint_arguments;
};
G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
// Called when first Flutter frame received.
static void first_frame_cb(MyApplication* self, FlView* view) {
gtk_widget_show(gtk_widget_get_toplevel(GTK_WIDGET(view)));
}
// Implements GApplication::activate.
static void my_application_activate(GApplication* application) {
MyApplication* self = MY_APPLICATION(application);
GtkWindow* window =
GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
// Use a header bar when running in GNOME as this is the common style used
// by applications and is the setup most users will be using (e.g. Ubuntu
// desktop).
// If running on X and not using GNOME then just use a traditional title bar
// in case the window manager does more exotic layout, e.g. tiling.
// If running on Wayland assume the header bar will work (may need changing
// if future cases occur).
gboolean use_header_bar = TRUE;
#ifdef GDK_WINDOWING_X11
GdkScreen* screen = gtk_window_get_screen(window);
if (GDK_IS_X11_SCREEN(screen)) {
const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
use_header_bar = FALSE;
}
}
#endif
if (use_header_bar) {
GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
gtk_widget_show(GTK_WIDGET(header_bar));
gtk_header_bar_set_title(header_bar, "Pipelines");
gtk_header_bar_set_show_close_button(header_bar, TRUE);
gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
} else {
gtk_window_set_title(window, "Pipelines");
}
gtk_window_set_default_size(window, 1280, 720);
g_autoptr(FlDartProject) project = fl_dart_project_new();
fl_dart_project_set_dart_entrypoint_arguments(
project, self->dart_entrypoint_arguments);
FlView* view = fl_view_new(project);
GdkRGBA background_color;
// Background defaults to black, override it here if necessary, e.g. #00000000
// for transparent.
gdk_rgba_parse(&background_color, "#000000");
fl_view_set_background_color(view, &background_color);
gtk_widget_show(GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
// Show the window when Flutter renders.
// Requires the view to be realized so we can start rendering.
g_signal_connect_swapped(view, "first-frame", G_CALLBACK(first_frame_cb),
self);
gtk_widget_realize(GTK_WIDGET(view));
fl_register_plugins(FL_PLUGIN_REGISTRY(view));
gtk_widget_grab_focus(GTK_WIDGET(view));
}
// Implements GApplication::local_command_line.
static gboolean my_application_local_command_line(GApplication* application,
gchar*** arguments,
int* exit_status) {
MyApplication* self = MY_APPLICATION(application);
// Strip out the first argument as it is the binary name.
self->dart_entrypoint_arguments = g_strdupv(*arguments + 1);
g_autoptr(GError) error = nullptr;
if (!g_application_register(application, nullptr, &error)) {
g_warning("Failed to register: %s", error->message);
*exit_status = 1;
return TRUE;
}
g_application_activate(application);
*exit_status = 0;
return TRUE;
}
// Implements GApplication::startup.
static void my_application_startup(GApplication* application) {
// MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application startup.
G_APPLICATION_CLASS(my_application_parent_class)->startup(application);
}
// Implements GApplication::shutdown.
static void my_application_shutdown(GApplication* application) {
// MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application shutdown.
G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application);
}
// Implements GObject::dispose.
static void my_application_dispose(GObject* object) {
MyApplication* self = MY_APPLICATION(object);
g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}
static void my_application_class_init(MyApplicationClass* klass) {
G_APPLICATION_CLASS(klass)->activate = my_application_activate;
G_APPLICATION_CLASS(klass)->local_command_line =
my_application_local_command_line;
G_APPLICATION_CLASS(klass)->startup = my_application_startup;
G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown;
G_OBJECT_CLASS(klass)->dispose = my_application_dispose;
}
static void my_application_init(MyApplication* self) {}
MyApplication* my_application_new() {
// Set the program name to the application ID, which helps various systems
// like GTK and desktop environments map this running application to its
// corresponding .desktop file. This ensures better integration by allowing
// the application to be recognized beyond its binary name.
g_set_prgname(APPLICATION_ID);
return MY_APPLICATION(g_object_new(my_application_get_type(),
"application-id", APPLICATION_ID, "flags",
G_APPLICATION_NON_UNIQUE, nullptr));
}
+21
View File
@@ -0,0 +1,21 @@
#ifndef FLUTTER_MY_APPLICATION_H_
#define FLUTTER_MY_APPLICATION_H_
#include <gtk/gtk.h>
G_DECLARE_FINAL_TYPE(MyApplication,
my_application,
MY,
APPLICATION,
GtkApplication)
/**
* my_application_new:
*
* Creates a new Flutter-based application.
*
* Returns: a new #MyApplication.
*/
MyApplication* my_application_new();
#endif // FLUTTER_MY_APPLICATION_H_
+3 -3
View File
@@ -471,7 +471,7 @@
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES; GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 10.15; MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
SDKROOT = macosx; SDKROOT = macosx;
SWIFT_COMPILATION_MODE = wholemodule; SWIFT_COMPILATION_MODE = wholemodule;
@@ -553,7 +553,7 @@
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES; GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 10.15; MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = YES; MTL_ENABLE_DEBUG_INFO = YES;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx; SDKROOT = macosx;
@@ -603,7 +603,7 @@
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES; GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 10.15; MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
SDKROOT = macosx; SDKROOT = macosx;
SWIFT_COMPILATION_MODE = wholemodule; SWIFT_COMPILATION_MODE = wholemodule;
+34
View File
@@ -154,6 +154,40 @@ signed with the key in `~/.config/pipelines/android/` (seeded from
`~/.android/debug.keystore` if present), so each build installs over the last. `~/.android/debug.keystore` if present), so each build installs over the last.
Options: `--server-url ws(s)://host:port/connect`, `--notes TEXT`, `--prefix`. Options: `--server-url ws(s)://host:port/connect`, `--notes TEXT`, `--prefix`.
### Desktop clients
```sh
./install --linux --output ./dist
./install --macos --flutter /path/to/flutter --output ./dist
# Offer this desktop build through an installed server's update feed:
./install --linux --publish --notes "Release notes"
./install --macos --flutter /path/to/flutter --publish
```
Linux builds use Docker on Linux or macOS and target **Linux x64**. Extract the
entire `pipelines-linux-x64.tar.gz` archive and run `pipelines-linux-x64/pipelines-app`;
keep its `lib/` and `data/` siblings together. The executable has a distinct name
from the `pipelines` server CLI. The target Linux desktop needs GTK 3 and its
runtime libraries (Debian/Ubuntu: `libgtk-3-0`, `libstdc++6`, `liblzma5`). This is a
portable bundle, not a package-manager installation or a server installation.
macOS 12 or newer is required. macOS builds run natively with Xcode and the pinned Flutter version from
`app/.flutter-version`; they do not require Docker. The build targets the build
machine's architecture and records the actual executable architecture in the
feed. Unzip `Pipelines-macos.zip` and open `Pipelines.app`; move it to Applications
if desired. Local builds are not Developer ID notarized distribution packages.
Framework symlinks and executable permissions are preserved in the archive.
Both commands build in isolated source copies/containers, retain cached releases,
and do not install, launch or restart the server. `--server-url` optionally sets
the first server address; otherwise choose it in the app. `--output` copies the
archive to a chosen directory. `--publish` additionally requires an existing
installation (`--prefix` supported), copies a versioned archive into its update
directory, then atomically updates `/updates/linux-x64/version.json` or
`/updates/macos/version.json`. Feeds include platform, actual architectures,
version, SHA-256, and release notes. Android's existing feed remains separate.
Previously published archives remain available for downloads already in progress.
`./install --docker` is the optional Compose installation with its own `./install --docker` is the optional Compose installation with its own
container harness credentials; see [Docker](docker.md). Do not run it container harness credentials; see [Docker](docker.md). Do not run it
alongside a native install on the same ports. Its harnesses are set up with alongside a native install on the same ports. Its harnesses are set up with
+28
View File
@@ -0,0 +1,28 @@
# Desktop client build options
Added `./install --linux` (Docker Linux x64) and `./install --macos`
(native pinned Flutter + Xcode, host architecture). Both produce full client
archives without installing or restarting a server. macOS requires 12+;
its existing 10.15 project target failed against Xcode 27 and was corrected.
The supported Flutter `FLUTTER_XCODE_ARCHS` setting explicitly selects the
native host architecture; the cache includes that host identity. This avoids
claiming a universal binary, and feeds use actual `lipo -archs` output.
`--publish` offers versioned archives via the existing authenticated update
file server. Feeds carry platform, actual architectures, epoch-minute build
code, SHA-256, release notes, and relative archive filename. The same build
code is compiled into the client. Archive publication precedes atomic feed
replacement; old filenames remain available for in-flight downloads. Older
builds cannot overwrite newer feeds. Builds work without a server manifest
unless publication is requested.
Verification: 15 Python builder/cache/packaging/publication tests passed;
Python compilation, shell syntax, and diff checks passed. Real Docker x64
Linux release and native macOS arm64 release both built with Flutter 3.44.6.
The macOS archive retained nine framework symlinks, and `codesign --verify
--deep --strict` passed. Linux archive retained the complete lib/data bundle
and executable mode 0755; `ldd` inside the Debian builder found no missing
libraries. Logs: /tmp/pipelines-{linux,macos}-build.log and
/tmp/pipelines-linux-linkage.log. No desktop UI/device interaction was run;
these build checks do not establish runtime UI parity or public deployment.
Final app-source integration requires rebuilding changed-source artifacts.
+4
View File
@@ -27,6 +27,10 @@ case "$mode" in
shift shift
exec python3 scripts/app_build.py apk "$@" exec python3 scripts/app_build.py apk "$@"
;; ;;
--linux|linux|--macos|macos)
shift
exec python3 scripts/app_build.py "${mode#--}" "$@"
;;
--native|native) --native|native)
shift shift
exec python3 scripts/setup-native.py "$@" exec python3 scripts/setup-native.py "$@"
+42 -6
View File
@@ -13,6 +13,7 @@ unchanged app is never rebuilt.
""" """
import argparse import argparse
import hashlib import hashlib
import importlib.util
import json import json
import os import os
from pathlib import Path from pathlib import Path
@@ -34,10 +35,12 @@ KEEP = 3
# Inputs that change what a build produces. Generated and machine-local paths # Inputs that change what a build produces. Generated and machine-local paths
# (build/, .dart_tool/, android/local.properties) are left out. # (build/, .dart_tool/, android/local.properties) are left out.
SOURCES = { SOURCES = {
"web": ("lib", "web", "assets", "pubspec.yaml", "pubspec.lock", ".flutter-version", "docker"), "web": ("lib", "web", "assets", "fonts", "pubspec.yaml", "pubspec.lock", ".flutter-version", "docker"),
"apk": ("lib", "android", "assets", "pubspec.yaml", "pubspec.lock", ".flutter-version", "docker"), "apk": ("lib", "android", "assets", "fonts", "pubspec.yaml", "pubspec.lock", ".flutter-version", "docker"),
"linux": ("lib", "linux", "assets", "fonts", "pubspec.yaml", "pubspec.lock", ".flutter-version", "docker"),
"macos": ("lib", "macos", "assets", "fonts", "pubspec.yaml", "pubspec.lock", ".flutter-version"),
} }
SKIPPED = {"build", ".dart_tool", ".gradle", ".cxx", "local.properties", ".DS_Store"} SKIPPED = {"build", ".dart_tool", ".gradle", ".cxx", "local.properties", ".DS_Store", "ephemeral", "Pods", ".symlinks"}
# This is part of the web cache key so entries made before release metadata was # This is part of the web cache key so entries made before release metadata was
# generated cannot be mistaken for complete web releases. # generated cannot be mistaken for complete web releases.
WEB_CACHE_SCHEMA = "web-release-metadata-v1" WEB_CACHE_SCHEMA = "web-release-metadata-v1"
@@ -54,6 +57,12 @@ def digest(kind, app=APP, extra=()):
hasher.update(kind.encode()) hasher.update(kind.encode())
if kind == "web": if kind == "web":
hasher.update(b"\0cache-schema\0" + WEB_CACHE_SCHEMA.encode()) hasher.update(b"\0cache-schema\0" + WEB_CACHE_SCHEMA.encode())
if kind in ("linux", "macos"):
hasher.update(b"\0cache-schema\0desktop-v1")
for script in (Path(__file__), Path(__file__).with_name("app_desktop_build.py")):
hasher.update(b"\0builder\0" + script.read_bytes())
if kind == "linux":
hasher.update(b"\0platform\0linux/amd64")
for item in extra: for item in extra:
hasher.update(b"\0arg\0" + item.encode()) hasher.update(b"\0arg\0" + item.encode())
for name in SOURCES[kind]: for name in SOURCES[kind]:
@@ -107,12 +116,12 @@ def docker_available(runner=subprocess.run):
def image(kind, runner, app=APP): def image(kind, runner, app=APP):
"""Builds (or reuses, via Docker's layer cache) the build image for [kind].""" """Builds (or reuses, via Docker's layer cache) the build image for [kind]."""
target = "android" if kind == "apk" else "web" target = {"apk": "android", "linux": "linux"}.get(kind, "web")
version = flutter_version(app) version = flutter_version(app)
tag = f"pipelines-flutter-{target}:{version}" tag = f"pipelines-flutter-{target}:{version}"
args = ["build", "--target", target, "--build-arg", f"FLUTTER_VERSION={version}", "-t", tag, args = ["build", "--target", target, "--build-arg", f"FLUTTER_VERSION={version}", "-t", tag,
"-f", str(app / "docker/Dockerfile")] "-f", str(app / "docker/Dockerfile")]
if kind == "apk": if kind in ("apk", "linux"):
# Android's build tools (aapt2) ship for x86-64 Linux only. # Android's build tools (aapt2) ship for x86-64 Linux only.
args += ["--platform", "linux/amd64"] args += ["--platform", "linux/amd64"]
docker(runner, *args, str(app / "docker")) docker(runner, *args, str(app / "docker"))
@@ -140,6 +149,8 @@ def build(kind, runner=subprocess.run, app=APP, cache=None, arguments=(), log=pr
key = digest(kind, app, arguments) key = digest(kind, app, arguments)
entry = cache / f"{kind}-{key}" entry = cache / f"{kind}-{key}"
usable = web_cache_complete(entry) if kind == "web" else (entry / ".complete").is_file() usable = web_cache_complete(entry) if kind == "web" else (entry / ".complete").is_file()
if kind == "linux":
usable = usable and (entry / "pipelines-app").is_file() and (entry / "data/flutter_assets").is_dir() and (entry / "lib").is_dir()
if usable: if usable:
log(f"Reusing the {kind} build {key} (app sources unchanged).") log(f"Reusing the {kind} build {key} (app sources unchanged).")
return entry return entry
@@ -152,6 +163,8 @@ def build(kind, runner=subprocess.run, app=APP, cache=None, arguments=(), log=pr
command = ["run", "--rm", "--user", f"{os.getuid()}:{os.getgid()}", command = ["run", "--rm", "--user", f"{os.getuid()}:{os.getgid()}",
"-v", f"{app}:/src:ro", "-v", f"{work}:/out", "-v", f"{app}:/src:ro", "-v", f"{work}:/out",
"-v", "pipelines-flutter-pub:/home/builder/.pub-cache"] "-v", "pipelines-flutter-pub:/home/builder/.pub-cache"]
if kind == "linux":
command += ["--platform", "linux/amd64"]
if kind == "apk": if kind == "apk":
command += ["--platform", "linux/amd64", command += ["--platform", "linux/amd64",
"-v", "pipelines-flutter-gradle:/home/builder/.gradle", "-v", "pipelines-flutter-gradle:/home/builder/.gradle",
@@ -165,6 +178,8 @@ def build(kind, runner=subprocess.run, app=APP, cache=None, arguments=(), log=pr
# this avoids circular hashing while keeping the compiled app and # this avoids circular hashing while keeping the compiled app and
# its published metadata on the same identity. # its published metadata on the same identity.
build_arguments += (f"--dart-define=PIPELINES_WEB_BUILD_ID={web_build_id(key)}",) build_arguments += (f"--dart-define=PIPELINES_WEB_BUILD_ID={web_build_id(key)}",)
if kind == "linux":
build_arguments += (f"--dart-define=PIPELINES_NATIVE_BUILD_CODE={built // 60}",)
if kind == "apk": if kind == "apk":
# Android installs only a higher build number over the last one, so # Android installs only a higher build number over the last one, so
# each build is stamped when it is made (minutes since the epoch); # each build is stamped when it is made (minutes since the epoch);
@@ -172,6 +187,9 @@ def build(kind, runner=subprocess.run, app=APP, cache=None, arguments=(), log=pr
code = built // 60 code = built // 60
stamp = (f"--build-number={code}", f"--build-name=0.1.{code}") stamp = (f"--build-number={code}", f"--build-name=0.1.{code}")
docker(runner, *command, tag, "pipelines-app-build", kind, *build_arguments, *stamp) docker(runner, *command, tag, "pipelines-app-build", kind, *build_arguments, *stamp)
if kind == "linux" and not ((work / "pipelines-app").is_file() and
(work / "data/flutter_assets").is_dir() and (work / "lib").is_dir()):
raise RuntimeError("Linux build did not produce its complete executable/data/lib bundle")
if kind == "web": if kind == "web":
(work / "release.json").write_text(json.dumps(web_release_metadata(key)) + "\n") (work / "release.json").write_text(json.dumps(web_release_metadata(key)) + "\n")
(work / ".complete").write_text(json.dumps({"key": key, "built": built}) + "\n") (work / ".complete").write_text(json.dumps({"key": key, "built": built}) + "\n")
@@ -270,11 +288,29 @@ def print_web_urls(manifest, lan_host=None):
def main(argv=None): def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("kind", choices=("web", "apk")) parser.add_argument("kind", choices=("web", "apk", "linux", "macos"))
parser.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX) parser.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX)
parser.add_argument("--server-url", help="APK default server (default: this installation's web address)") parser.add_argument("--server-url", help="APK default server (default: this installation's web address)")
parser.add_argument("--notes", default="", help="APK release notes shown in Check for updates") parser.add_argument("--notes", default="", help="APK release notes shown in Check for updates")
parser.add_argument("--publish", action="store_true", help="Publish desktop archive and update feed to this installation")
parser.add_argument("--output", type=Path, help="Desktop archive output directory (default: build cache)")
parser.add_argument("--flutter", help="Native Flutter executable for macOS (or PIPELINES_FLUTTER/PATH)")
args = parser.parse_args(argv) args = parser.parse_args(argv)
if args.kind in ("linux", "macos"):
spec = importlib.util.spec_from_file_location("pipelines_desktop_build", Path(__file__).with_name("app_desktop_build.py"))
desktop = importlib.util.module_from_spec(spec)
spec.loader.exec_module(desktop)
bundle, archive = desktop.build_desktop(args.kind, app=APP, cache=default_cache(), runner=subprocess.run,
source_digest=digest, docker_build=build, docker_ready=docker_available,
server_url=args.server_url, flutter=args.flutter, output=args.output,
prune_cache=prune)
if args.publish:
manifest = load_manifest(args.prefix)
updates = (manifest.get("web") or {}).get("updates")
if not updates:
raise ValueError("This installation has no app update directory; rerun ./install")
desktop.publish_desktop(args.kind, bundle, archive, Path(updates), notes=args.notes)
return
if not docker_available(): if not docker_available():
raise RuntimeError("Docker is required to build the app; start Docker and retry") raise RuntimeError("Docker is required to build the app; start Docker and retry")
if args.kind == "apk": if args.kind == "apk":
+192
View File
@@ -0,0 +1,192 @@
"""Standalone desktop client artifacts; never installs or restarts a server."""
import hashlib
import json
import os
from pathlib import Path
import platform
import shutil
import subprocess
import tarfile
import tempfile
import time
from urllib.parse import urlsplit
def _run(runner, command, **kwargs):
try:
result = runner(command, **kwargs)
except subprocess.TimeoutExpired as error:
raise RuntimeError(f"{command[0]} timed out") from error
if result.returncode:
raise RuntimeError(f"{command[0]} failed; see its build output")
return result
def _arguments(server_url):
if not server_url:
return ()
parsed = urlsplit(server_url)
if parsed.scheme not in ("ws", "wss", "http", "https") or not parsed.hostname or parsed.username or parsed.password or parsed.fragment:
raise ValueError("--server-url must be a server address without embedded credentials or fragment")
return (f"--dart-define=PIPELINES_SERVER_URL={server_url}",)
def _linux_archive(entry):
archive = entry / "pipelines-linux-x64.tar.gz"
if archive.is_file():
return archive
staged = archive.with_suffix(".gz.next")
try:
with tarfile.open(staged, "w:gz") as output:
for child in sorted(entry.iterdir()):
if child.name not in (".complete", archive.name, staged.name):
output.add(child, arcname=f"pipelines-linux-x64/{child.name}")
os.replace(staged, archive)
finally:
staged.unlink(missing_ok=True)
return archive
def _macos_build(*, app, cache, source_digest, runner, arguments, flutter, log):
if platform.system() != "Darwin":
raise ValueError("macOS clients must be built natively on macOS with Xcode")
selected = flutter or os.environ.get("PIPELINES_FLUTTER") or shutil.which("flutter")
if not selected:
raise ValueError("Flutter is required; pass --flutter /path/to/flutter or set PIPELINES_FLUTTER")
selected = str(Path(selected).expanduser())
version = _run(runner, [selected, "--version", "--machine"], capture_output=True, text=True, timeout=60)
try:
actual = json.loads(version.stdout)["frameworkVersion"]
except (ValueError, KeyError, TypeError) as error:
raise ValueError("The selected Flutter SDK did not report its version") from error
pinned = (app / ".flutter-version").read_text().strip()
if actual != pinned:
raise ValueError(f"Flutter {pinned} is required; selected SDK is {actual}. No SDK was changed.")
xcode = _run(runner, ["xcodebuild", "-version"], capture_output=True, text=True, timeout=30)
identity = ("native-macos-v1", platform.machine(), xcode.stdout.strip(), actual)
key = source_digest("macos", app=app, extra=arguments + identity)
entry = cache / f"macos-{key}"
bundle = entry / "Pipelines.app"
archive = entry / "Pipelines-macos.zip"
if (entry / ".complete").is_file() and (bundle / "Contents/MacOS/Pipelines").is_file() and archive.is_file():
log(f"Reusing native macOS build {key}.")
return entry, bundle, archive
cache.mkdir(parents=True, exist_ok=True)
staging = Path(tempfile.mkdtemp(prefix="macos-", dir=cache))
try:
with tempfile.TemporaryDirectory(prefix="pipelines-macos-source-") as temporary:
work = Path(temporary) / "app"
shutil.copytree(app, work, symlinks=True, ignore=shutil.ignore_patterns(
"build", ".dart_tool", "Pods", "ephemeral", ".symlinks", ".gradle", ".cxx", "local.properties", ".DS_Store"))
_run(runner, [selected, "pub", "get"], cwd=work, timeout=300)
built = int(time.time())
_run(runner, [selected, "build", "macos", "--release", "--no-pub", *arguments,
f"--build-number={built // 60}",
f"--dart-define=PIPELINES_NATIVE_BUILD_CODE={built // 60}"], cwd=work, timeout=1200,
env={**os.environ, "FLUTTER_XCODE_ARCHS": {"aarch64": "arm64", "x86_64": "x86_64"}.get(platform.machine(), platform.machine())})
native = work / "build/macos/Build/Products/Release/Pipelines.app"
if not (native / "Contents/MacOS/Pipelines").is_file():
raise RuntimeError("Flutter did not produce a complete Pipelines.app")
arches = _run(runner, ["lipo", "-archs", str(native / "Contents/MacOS/Pipelines")],
capture_output=True, text=True, timeout=30).stdout.split()
architectures = sorted({{"x86_64": "x64", "arm64": "arm64"}.get(a, a) for a in arches})
if not architectures or any(a not in ("x64", "arm64") for a in architectures):
raise RuntimeError("macOS bundle has unsupported or missing architectures")
# Framework symlinks and executable modes are part of the bundle.
shutil.copytree(native, staging / "Pipelines.app", symlinks=True)
_run(runner, ["ditto", "-c", "-k", "--keepParent", str(staging / "Pipelines.app"),
str(staging / archive.name)], timeout=120)
if not (staging / archive.name).is_file():
raise RuntimeError("macOS archive was not created")
(staging / ".complete").write_text(json.dumps({"key": key, "built": built, "architectures": architectures}) + "\n")
if entry.exists():
previous = entry.with_name(entry.name + ".previous")
if previous.exists():
raise RuntimeError(f"A previous build is retained at {previous}; no files were replaced")
entry.rename(previous)
try:
staging.rename(entry)
except BaseException:
previous.rename(entry)
raise
shutil.rmtree(previous)
else:
staging.rename(entry)
finally:
if staging.exists():
shutil.rmtree(staging)
return entry, bundle, archive
def build_desktop(kind, *, app, cache, runner, source_digest, docker_build,
docker_ready, server_url=None, flutter=None, output=None, log=print,
prune_cache=None):
arguments = _arguments(server_url)
if kind == "macos":
entry, bundle, archive = _macos_build(app=app, cache=cache, runner=runner,
source_digest=source_digest, arguments=arguments, flutter=flutter, log=log)
elif kind == "linux":
if not docker_ready(runner):
raise RuntimeError("Docker is required for the Linux x64 client; start Docker and retry")
entry = docker_build("linux", app=app, cache=cache, runner=runner, arguments=arguments, log=log)
if not (entry / "pipelines-app").is_file() or not (entry / "data/flutter_assets").is_dir() or not (entry / "lib").is_dir():
raise RuntimeError("Linux build is missing its executable, data or libraries")
bundle, archive = entry, _linux_archive(entry)
else:
raise ValueError(f"Unknown desktop target: {kind}")
if prune_cache is not None:
prune_cache(cache, kind, keep=entry)
if output is not None:
output = Path(output).expanduser()
output.mkdir(parents=True, exist_ok=True)
published = output / archive.name
descriptor, temporary = tempfile.mkstemp(prefix=archive.name + ".", dir=output)
os.close(descriptor)
try:
shutil.copy2(archive, temporary)
os.replace(temporary, published)
finally:
Path(temporary).unlink(missing_ok=True)
archive = published
log(f"Desktop client bundle: {bundle}")
log(f"Desktop client archive: {archive}")
log("No server was installed or restarted. Choose your server in the app.")
return bundle, archive
def publish_desktop(kind, bundle, archive, updates, *, notes="", log=print):
"""Publish archive before its feed; versioned names preserve in-flight reads."""
entry = bundle.parent if kind == "macos" else bundle
complete = json.loads((entry / ".complete").read_text())
code = int(complete["built"]) // 60
architectures = complete.get("architectures") if kind == "macos" else ["x64"]
if not architectures or any(a not in ("x64", "arm64") for a in architectures):
raise ValueError("Build metadata has no supported architecture")
digest = hashlib.sha256(archive.read_bytes()).hexdigest()
suffix = ".zip" if kind == "macos" else ".tar.gz"
stem = "Pipelines-macos" if kind == "macos" else "pipelines-linux-x64"
filename = f"{stem}-{code}-{digest[:8]}{suffix}"
target = updates / ("macos" if kind == "macos" else "linux-x64")
target.mkdir(parents=True, exist_ok=True)
metadata = {"versionCode": code, "versionName": f"0.1.{code}",
"platform": kind, "architectures": architectures, "file": filename,
"sha256": digest, "notes": notes}
feed = target / "version.json"
if feed.exists():
previous = json.loads(feed.read_text())
if previous.get("versionCode", 0) > code:
raise ValueError("Refusing to publish an older build over a newer update")
for destination, content in ((target / filename, archive.read_bytes()),
(feed, (json.dumps(metadata) + "\n").encode())):
descriptor, temporary = tempfile.mkstemp(prefix=destination.name + ".", dir=target)
try:
with os.fdopen(descriptor, "wb") as output:
output.write(content)
output.flush()
os.fsync(output.fileno())
os.chmod(temporary, 0o644)
os.replace(temporary, destination)
finally:
Path(temporary).unlink(missing_ok=True)
log(f"Published {kind} update {code} at {feed}")
return metadata
+178
View File
@@ -0,0 +1,178 @@
import importlib.util
import json
from pathlib import Path
import subprocess
import tarfile
import tempfile
import unittest
from unittest.mock import patch
def load(name):
spec = importlib.util.spec_from_file_location(name, Path(__file__).with_name(name + ".py"))
result = importlib.util.module_from_spec(spec)
spec.loader.exec_module(result)
return result
core = load("app_build")
desktop = load("app_desktop_build")
class Runner:
def __init__(self):
self.calls = []
self.native_env = None
self.fail_native = False
self.version = "3.44.6"
def __call__(self, command, **kwargs):
self.calls.append(command)
stdout = ""
code = 0
if "--machine" in command:
stdout = json.dumps({"frameworkVersion": self.version})
elif command[:2] == ["xcodebuild", "-version"]:
stdout = "Xcode 27.0\nBuild version 27A266a"
elif command[:2] == ["docker", "run"]:
output = Path(next(arg[:-5] for arg in command if arg.endswith(":/out")))
(output / "pipelines-app").write_bytes(b"linux-client")
(output / "pipelines-app").chmod(0o755)
(output / "data/flutter_assets").mkdir(parents=True)
(output / "data/flutter_assets/font.ttf").write_bytes(b"font")
(output / "lib").mkdir()
(output / "lib/engine.so").write_bytes(b"engine")
elif command[1:3] == ["build", "macos"]:
self.native_env = kwargs.get("env")
if self.fail_native:
code = 1
else:
app = Path(kwargs["cwd"]) / "build/macos/Build/Products/Release/Pipelines.app"
(app / "Contents/MacOS").mkdir(parents=True)
(app / "Contents/MacOS/Pipelines").write_bytes(b"macos-client")
(app / "Contents/MacOS/Pipelines").chmod(0o755)
framework = app / "Contents/Frameworks/Fixture.framework"
(framework / "Versions/A").mkdir(parents=True)
(framework / "Versions/A/Fixture").write_bytes(b"framework")
(framework / "Versions/Current").symlink_to("A")
(framework / "Fixture").symlink_to("Versions/Current/Fixture")
elif command[:2] == ["lipo", "-archs"]:
stdout = "x86_64 arm64"
elif command[0] == "ditto":
Path(command[-1]).write_bytes(b"archive")
return subprocess.CompletedProcess(command, code, stdout=stdout, stderr="")
class DesktopBuildTests(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory()
self.addCleanup(self.temporary.cleanup)
self.root = Path(self.temporary.name)
self.app = self.root / "app"
for directory in ("lib", "fonts", "linux", "macos", "docker"):
(self.app / directory).mkdir(parents=True, exist_ok=True)
(self.app / "lib/main.dart").write_text("main() {}")
(self.app / ".flutter-version").write_text("3.44.6\n")
self.runner = Runner()
def build(self, kind, **kwargs):
return desktop.build_desktop(kind, app=self.app, cache=self.root / "cache",
runner=self.runner, source_digest=core.digest, docker_build=core.build,
docker_ready=lambda *_: True, log=lambda *_: None, **kwargs)
def test_linux_is_x64_and_packages_full_bundle_without_installation(self):
bundle, archive = self.build("linux", output=self.root / "artifacts")
builds = [c for c in self.runner.calls if c[:2] == ["docker", "build"]]
self.assertEqual(builds[0][builds[0].index("--target") + 1], "linux")
for command in [builds[0], next(c for c in self.runner.calls if c[:2] == ["docker", "run"])]:
self.assertEqual(command[command.index("--platform") + 1], "linux/amd64")
with tarfile.open(archive) as package:
self.assertTrue({"pipelines-linux-x64/pipelines-app", "pipelines-linux-x64/lib/engine.so",
"pipelines-linux-x64/data/flutter_assets/font.ttf"}.issubset(package.getnames()))
self.assertEqual(package.getmember("pipelines-linux-x64/pipelines-app").mode & 0o111, 0o111)
self.assertTrue(bundle.is_dir())
before = len(self.runner.calls)
self.build("linux")
self.assertEqual(len(self.runner.calls), before)
def test_font_and_target_sources_invalidate_correct_caches(self):
keys = {kind: core.digest(kind, self.app) for kind in core.SOURCES}
(self.app / "fonts/font.ttf").write_bytes(b"new font")
for kind in core.SOURCES:
self.assertNotEqual(keys[kind], core.digest(kind, self.app), kind)
linux = core.digest("linux", self.app)
macos = core.digest("macos", self.app)
(self.app / "linux/CMakeLists.txt").write_text("changed native runner")
self.assertNotEqual(linux, core.digest("linux", self.app))
self.assertEqual(macos, core.digest("macos", self.app))
generated = self.app / "macos/Flutter/ephemeral"
generated.mkdir(parents=True)
(generated / "local-path").write_text("machine-specific generated value")
self.assertEqual(macos, core.digest("macos", self.app))
@patch.object(desktop.platform, "system", return_value="Darwin")
def test_native_macos_preserves_framework_symlinks_and_reuses_build(self, _):
bundle, archive = self.build("macos", flutter="/fixture/flutter")
self.assertTrue((bundle / "Contents/Frameworks/Fixture.framework/Versions/Current").is_symlink())
self.assertEqual((bundle / "Contents/MacOS/Pipelines").stat().st_mode & 0o111, 0o111)
self.assertTrue(archive.is_file())
self.build("macos", flutter="/fixture/flutter")
self.assertEqual(sum(c[1:3] == ["build", "macos"] for c in self.runner.calls), 1)
self.assertFalse(any(c[0] == "docker" for c in self.runner.calls))
self.assertFalse((self.app / "build").exists())
expected = {"aarch64": "arm64", "x86_64": "x86_64"}.get(desktop.platform.machine(), desktop.platform.machine())
self.assertEqual(self.runner.native_env["FLUTTER_XCODE_ARCHS"], expected)
@patch.object(desktop.platform, "system", return_value="Darwin")
def test_failed_native_build_preserves_previous_artifact(self, _):
bundle, archive = self.build("macos", flutter="/fixture/flutter")
previous = archive.read_bytes()
(self.app / "lib/main.dart").write_text("changed application")
self.runner.fail_native = True
with self.assertRaisesRegex(RuntimeError, "failed"):
self.build("macos", flutter="/fixture/flutter")
self.assertEqual(archive.read_bytes(), previous)
self.assertTrue((bundle / "Contents/MacOS/Pipelines").is_file())
@patch.object(desktop.platform, "system", return_value="Darwin")
def test_wrong_sdk_fails_before_building_or_changing_any_sdk(self, _):
self.runner.version = "3.47.0"
with self.assertRaisesRegex(ValueError, "3.44.6 is required"):
self.build("macos", flutter="/fixture/flutter")
self.assertEqual(len(self.runner.calls), 1)
@patch.object(desktop.platform, "system", return_value="Linux")
def test_macos_refuses_non_macos_host_without_docker_fallback(self, _):
with self.assertRaisesRegex(ValueError, "natively on macOS"):
self.build("macos")
self.assertEqual(self.runner.calls, [])
def test_linux_publication_has_matching_hash_and_rejects_downgrade(self):
bundle, archive = self.build("linux")
updates = self.root / "updates"
metadata = desktop.publish_desktop("linux", bundle, archive, updates, log=lambda *_: None)
target = updates / "linux-x64"
self.assertEqual(json.loads((target / "version.json").read_text()), metadata)
self.assertEqual(metadata["architectures"], ["x64"])
self.assertEqual(metadata["sha256"], desktop.hashlib.sha256((target / metadata["file"]).read_bytes()).hexdigest())
metadata["versionCode"] += 1
(target / "version.json").write_text(json.dumps(metadata))
with self.assertRaisesRegex(ValueError, "older build"):
desktop.publish_desktop("linux", bundle, archive, updates)
@patch.object(desktop.platform, "system", return_value="Darwin")
def test_macos_feed_uses_actual_architectures_and_native_build_stamp(self, _):
bundle, archive = self.build("macos", flutter="/fixture/flutter")
metadata = desktop.publish_desktop("macos", bundle, archive, self.root / "updates", log=lambda *_: None)
self.assertEqual(metadata["architectures"], ["arm64", "x64"])
command = next(c for c in self.runner.calls if c[1:3] == ["build", "macos"])
self.assertIn(f"--dart-define=PIPELINES_NATIVE_BUILD_CODE={metadata['versionCode']}", command)
def test_desktop_server_prefill_rejects_embedded_credentials(self):
with self.assertRaisesRegex(ValueError, "embedded credentials"):
self.build("linux", server_url="wss://secret@example.com/connect")
self.assertEqual(self.runner.calls, [])
if __name__ == "__main__":
unittest.main()