effindom-native-packaging 0.1.0

SDK-neutral native packaging primitives for EffinDOM applications
Documentation
use super::common::{
    copy_tree, create_dir_all, finalize_artifact, prepare_output, run_tool, unique_path,
    verified_record, write_executable, DistributionArtifact,
};
use crate::icon_encoding::encode_png;
use crate::{
    encode_linux_desktop_entry, ApplicationMetadata, Error, IconRasterSet, OverwritePolicy,
    PackageArchitecture, PackageOperatingSystem, Result,
};
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct AppImageInputs {
    pub bundle_root: PathBuf,
    pub package_record: PathBuf,
    pub destination: PathBuf,
    pub executable: PathBuf,
    pub metadata: ApplicationMetadata,
    pub categories: Vec<String>,
    pub icons: IconRasterSet,
    pub appimagetool: PathBuf,
    pub unsquashfs: PathBuf,
}

pub fn create_appimage(
    inputs: &AppImageInputs,
    overwrite: OverwritePolicy,
) -> Result<DistributionArtifact> {
    let record = verified_record(
        &inputs.bundle_root,
        &inputs.package_record,
        PackageOperatingSystem::Linux,
        "AppImage",
    )?;
    let architecture = match record.metadata.architecture {
        PackageArchitecture::X64 => "x86_64",
        PackageArchitecture::Arm64 => "aarch64",
        PackageArchitecture::Universal => {
            return Err(Error::DistributionTargetMismatch {
                format: "AppImage",
                actual: "Linux/universal".to_string(),
            });
        }
    };
    let destination = prepare_output(&inputs.destination, overwrite)?;
    let app_dir = unique_path(&destination, "AppDir")?;
    create_dir_all(&app_dir, "create AppDir")?;
    let temporary = unique_path(&destination, "appimage-output")?;
    let result = (|| {
        prepare_layout(inputs, &app_dir)?;
        run_tool(
            "appimagetool",
            "create AppImage",
            &destination,
            Command::new(&inputs.appimagetool)
                .arg("--no-appstream")
                .arg(&app_dir)
                .arg(&temporary)
                .env("ARCH", architecture),
        )?;
        verify_appimage(inputs, &temporary)?;
        fs::rename(&temporary, &destination).map_err(|source| Error::ArchiveIo {
            operation: "publish AppImage",
            path: destination.clone(),
            source,
        })?;
        finalize_artifact(
            destination,
            &inputs.bundle_root.join(&inputs.package_record),
            record,
        )
    })();
    let _ = fs::remove_dir_all(app_dir);
    if result.is_err() {
        let _ = fs::remove_file(temporary);
    }
    result
}

fn prepare_layout(inputs: &AppImageInputs, app_dir: &Path) -> Result<()> {
    let usr = app_dir.join("usr");
    copy_tree(&inputs.bundle_root, &usr)?;
    let desktop = encode_linux_desktop_entry(&inputs.metadata, &inputs.categories)?;
    let desktop_path = app_dir.join(desktop.relative_path);
    fs::write(&desktop_path, desktop.bytes).map_err(|source| Error::ArchiveIo {
        operation: "write AppImage desktop entry",
        path: desktop_path,
        source,
    })?;
    let icon = inputs.icons.get(256).ok_or(Error::MissingIconRaster(256))?;
    let icon_path = app_dir.join(format!("{}.png", inputs.metadata.executable_name));
    fs::write(&icon_path, encode_png(icon)?).map_err(|source| Error::ArchiveIo {
        operation: "write AppImage icon",
        path: icon_path,
        source,
    })?;
    let executable = inputs.executable.to_string_lossy();
    let app_run = format!(
        "#!/bin/sh\nset -eu\nHERE=$(CDPATH= cd -- \"$(dirname -- \"$0\")\" && pwd)\nexec \"$HERE/usr/{executable}\" \"$@\"\n"
    );
    write_executable(&app_dir.join("AppRun"), app_run.as_bytes())
}

fn verify_appimage(inputs: &AppImageInputs, appimage: &Path) -> Result<()> {
    let extraction_parent = unique_path(appimage, "appimage-extracted")?;
    let extracted = extraction_parent.join("squashfs-root");
    create_dir_all(&extraction_parent, "create AppImage extraction directory")?;
    let offset = squashfs_offset(appimage)?;
    run_tool(
        "unsquashfs",
        "extract AppImage without FUSE",
        appimage,
        Command::new(&inputs.unsquashfs)
            .args(["-f", "-d"])
            .arg(&extracted)
            .arg("-o")
            .arg(offset.to_string())
            .arg(appimage),
    )?;
    let result = crate::verify_bundle(extracted.join("usr"), &inputs.package_record);
    let _ = fs::remove_dir_all(extraction_parent);
    result.map(|_| ())
}

fn squashfs_offset(appimage: &Path) -> Result<usize> {
    let bytes = fs::read(appimage).map_err(|source| Error::ArchiveIo {
        operation: "read AppImage for SquashFS offset",
        path: appimage.to_path_buf(),
        source,
    })?;
    bytes
        .windows(4)
        .rposition(|window| window == b"hsqs")
        .ok_or_else(|| Error::DistributionTool {
            tool: "AppImage",
            operation: "locate embedded SquashFS filesystem",
            path: appimage.to_path_buf(),
            message: "SquashFS magic was not found".to_string(),
        })
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{IconAlpha, IconRaster, IconSourceFormat, NativeVersion};

    #[test]
    fn app_run_uses_executable_relative_to_its_appdir() {
        let root =
            std::env::temp_dir().join(format!("effindom-appdir-test-{}", std::process::id()));
        let bundle = root.join("bundle");
        fs::create_dir_all(bundle.join("bin")).unwrap();
        fs::write(bundle.join("bin/sample"), "sample").unwrap();
        let inputs = AppImageInputs {
            bundle_root: bundle,
            package_record: PathBuf::from("effindom-package.json"),
            destination: root.join("sample.AppImage"),
            executable: PathBuf::from("bin/sample"),
            metadata: ApplicationMetadata::new(
                "sample",
                "1.0.0",
                NativeVersion::new(1, 0, 0, 0),
                "Sample",
                "dev.effindom.sample",
            )
            .unwrap(),
            categories: vec!["Utility".to_string()],
            icons: IconRasterSet {
                source_format: IconSourceFormat::Png,
                source_width: 256,
                source_height: 256,
                alpha: IconAlpha::Opaque,
                rasters: vec![IconRaster {
                    size: 256,
                    rgba8: vec![255; 256 * 256 * 4],
                }],
            },
            appimagetool: PathBuf::from("appimagetool"),
            unsquashfs: PathBuf::from("unsquashfs"),
        };
        let app_dir = root.join("AppDir");
        prepare_layout(&inputs, &app_dir).unwrap();
        let launcher = fs::read_to_string(app_dir.join("AppRun")).unwrap();
        assert!(launcher.contains("$HERE/usr/bin/sample"));
        assert!(app_dir.join("sample.desktop").is_file());
        assert!(app_dir.join("sample.png").is_file());
        fs::remove_dir_all(root).unwrap();
    }
}