Add support for specifying arch

E.g., for bundling for i686 on x86_64.

Also,
* Added support for being explicit about arch (if arch is not explicitly specified in PackageBundler.toml juliaup.channel field.
* Added platform-dependent IntType to TestPackage, where Serialization fails to deserialize if WORD_SIZE differs from bundling arch to install arch.

Author: stemann

src/PackageBundler.jl

@@ -91,6 +91,9 @@ options, each of which are tried in turn until one is found that can be used to
 select the correct Julia version. If no multiplexer is found then the current
 `julia` is used.
 
+The `arch_explicit` field is a boolean flag that determines whether the architecture
+used for bundling should be explicitly defined in the generated bundle.
+
 The `handlers` field is a list of paths to handler scripts that are used to
 inject or transform code in the bundled packages. The handler scripts must be
 valid Julia files that return a `Function` accepting the required arguments as
@@ -109,6 +112,8 @@ listed below. The valid names for handlers are:
 function bundle(
     config::AbstractString = "PackageBundler.toml";
     clean::Bool = false,
+    arch::Union{Symbol,Nothing} = nothing,
+    arch_explicit::Bool = false,
     artifacts_url::Union{String,Nothing} = nothing,
 )
     config = abspath(config)
@@ -178,6 +183,9 @@ function bundle(
     # `julia_version`.
     multiplexers = String.(get(Vector{String}, config, "multiplexers"))
 
+    # Explicitly define the architecture used for bundling.
+    arch_explicit = get(config, "arch_explicit", arch_explicit)::Bool
+
     # Ensure handler scripts valid files and adjust paths to be absolute.
     handlers = Dict{String,String}()
     for file in String.(get(Vector{String}, config, "handlers"))
@@ -205,6 +213,8 @@ function bundle(
             key_pair = (; private, public),
             handlers = handlers,
             multiplexers = multiplexers,
+            arch = arch,
+            arch_explicit = arch_explicit,
         )
         for output in outputs
             output = normpath(joinpath(dir, output))

src/code_stripping.jl

@@ -11,6 +11,8 @@ function _generate_stripped_bundle(;
     key_pair::@NamedTuple{private::String, public::String},
     handlers::Dict,
     multiplexers::Vector{String},
+    arch::Union{Symbol,Nothing} = nothing,
+    arch_explicit::Bool = false,
 )
     output_dir = abspath(output_dir)
 
@@ -31,6 +33,8 @@ function _generate_stripped_bundle(;
             key_pair = key_pair,
             handlers = handlers,
             multiplexers = multiplexers,
+            arch = arch,
+            arch_explicit = arch_explicit,
         )
 
         for (k, v) in new_pkg_version_info
@@ -320,6 +324,8 @@ function _process_project_env(;
     key_pair::@NamedTuple{private::String, public::String},
     handlers::Dict,
     multiplexers::Vector{String},
+    arch::Union{Symbol,Nothing} = nothing,
+    arch_explicit::Bool = false
 )
     project_dir = normpath(project_dir)
     output_dir = normpath(output_dir)
@@ -349,7 +355,7 @@ function _process_project_env(;
     _sign_file(joinpath(named_environment, "Manifest.toml"), key_pair.private)
     write(joinpath(named_environment, basename(key_pair.public)), read(key_pair.public))
 
-    package_paths = _sniff_versions(project_dir, multiplexers)
+    package_paths = _sniff_versions(project_dir, multiplexers, arch)
 
     packagebundler_file = joinpath(project_dir, "PackageBundler.toml")
     packagebundler_toml =
@@ -358,6 +364,16 @@ function _process_project_env(;
     julia_version = TOML.parsefile(manifest_toml)["julia_version"]
     julia_version =
         get(get(Dict{String,Any}, packagebundler_toml, "juliaup"), "channel", julia_version)
+    if arch_explicit
+        packagebundler_toml = merge(packagebundler_toml, Dict(
+            "juliaup" => Dict(
+                "channel" => _juliaup_channel(julia_version, arch)
+            )
+        ))
+        open(joinpath(named_environment, "PackageBundler.toml"), "w") do io
+            TOML.print(io, packagebundler_toml)
+        end
+    end
 
     pkg_version_info = Dict()
     for (each_uuid, each_name) in stripped
@@ -374,6 +390,7 @@ function _process_project_env(;
                     key_pair,
                     handlers,
                     multiplexers,
+                    arch,
                 )
                 versions = get!(Dict{String,Any}, pkg_version_info, each_name)
                 versions[version_info["project"]["version"]] = version_info
@@ -395,14 +412,14 @@ end
 #     "julia_version" => v"<version>"
 # ))
 #
-function _sniff_versions(environment::AbstractString, multiplexers)
+function _sniff_versions(environment::AbstractString, multiplexers, arch::Union{Symbol,Nothing} = nothing)
     registries = Dict(
         reg.uuid => _process_reg_info_uuid_mapping(reg) for
         reg in Pkg.Registry.reachable_registries()
     )
     project = Base.env_project_file(environment)
     env = Pkg.Types.EnvCache(project)
-    stdlib_path = _get_stdlib_path(env, environment, multiplexers)
+    stdlib_path = _get_stdlib_path(env, environment, multiplexers, arch)
     output = Dict{String,Dict{String,Any}}()
     for (uuid, entry) in env.manifest.deps
         name = "$(entry.name)"
@@ -455,13 +472,13 @@ function _sniff_versions(environment::AbstractString, multiplexers)
     return output
 end
 
-function _get_stdlib_path(env, environment, multiplexers)
+function _get_stdlib_path(env, environment, multiplexers, arch::Union{Symbol,Nothing} = nothing)
     toml_file = joinpath(environment, "PackageBundler.toml")
     toml = isfile(toml_file) ? TOML.parsefile(toml_file) : Dict()
     juliaup = get(Dict, toml, "juliaup")
     channel = get(juliaup, "channel", nothing)
     version = something(channel, env.manifest.julia_version)
-    julia_bin = _process_multiplexers(multiplexers, version)
+    julia_bin = _process_multiplexers(multiplexers, version, arch)
     return read(
         `$julia_bin --startup-file=no -e 'import Pkg; print(Pkg.stdlib_dir())'`,
         String,
@@ -575,8 +592,9 @@ function _strip_package(
     key_pair::@NamedTuple{private::String, public::String},
     handlers::Dict,
     multiplexers::Vector{String},
+    arch::Union{Symbol,Nothing} = nothing,
 )
-    @info "Stripping source code." julia_version package
+    @info "Stripping source code." Sys.ARCH arch julia_version package
 
     package = abspath(package)
     output = abspath(output)
@@ -695,7 +713,7 @@ function _strip_package(
                     )
                 end
                 script = joinpath(@__DIR__, "serializer.jl")
-                binary = _process_multiplexers(multiplexers, julia_version)
+                binary = _process_multiplexers(multiplexers, julia_version, arch)
                 run(`$(binary) --startup-file=no $(script) $(toml_file)`)
             finally
                 rm(toml_file; force = true)
@@ -744,12 +762,13 @@ end
 function _process_multiplexers(
     multiplexers::Vector{String},
     julia_version::Union{String,VersionNumber},
+    arch::Union{Symbol,Nothing} = nothing,
 )
     for multiplexer in multiplexers
         exists = Sys.which(multiplexer)
         if !isnothing(exists)
             if multiplexer == "juliaup"
-                return `julia +$(julia_version)`
+                return `julia +$(_juliaup_channel(julia_version, arch))`
             elseif multiplexer == "asdf"
                 return withenv("ASDF_JULIA_VERSION" => "$(julia_version)") do
                     path = readchomp(`asdf which julia`)
@@ -771,3 +790,12 @@ function _process_multiplexers(
         error("no multiplexers found: $(repr(multiplexers))")
     end
 end
+
+function _juliaup_channel(julia_version::Union{String,VersionNumber}, arch::Union{Symbol,Nothing} = nothing)
+    if isnothing(arch)
+        return julia_version
+    end
+
+    juliaup_arch = if arch == :i686; :x86; elseif arch == :x86_64; :x64; else arch; end
+    return "$(julia_version)~$juliaup_arch"
+end

src/utilities.jl

@@ -7,7 +7,7 @@ version as specified in the `Manifest.toml` file. This uses either `juliaup` or
 `asdf` to switch between `julia` versions as needed. Make sure to have either of
 those installed, as well as the expected `julia` versions.
 """
-function instantiate(environments::String)
+function instantiate(environments::String; arch::Union{Symbol,Nothing} = nothing)
     if ispath(environments)
         if isfile(environments)
             error("The path '$environments' is a file, not a directory.")
@@ -35,11 +35,12 @@ function instantiate(environments::String)
             )
 
             if !isnothing(Sys.which("juliaup"))
-                @info "Checking whether Julia '$julia_version' is installed, if not, installing it."
-                run(`juliaup add $julia_version`)
+                juliaup_channel = _juliaup_channel(julia_version, arch)
+                @info "Checking whether Julia '$juliaup_channel' is installed, if not, installing it."
+                run(`juliaup add $juliaup_channel`)
                 withenv("JULIA_PKG_PRECOMPILE_AUTO" => 0) do
                     run(
-                        `julia +$(julia_version) --project=$each -e 'import Pkg; Pkg.instantiate()'`,
+                        `julia +$juliaup_channel --project=$each -e 'import Pkg; Pkg.instantiate()'`,
                     )
                 end
             elseif !isnothing(Sys.which("asdf"))

test/packages/TestPackage/0.1.0/src/TestPackage.jl

@@ -4,4 +4,10 @@ import Example
 
 greet() = print(Example.hello("0.1.0!"))
 
+struct IntType
+    i::Int
+end
+
+const INT_VALUE = IntType(42)
+
 end # module TestPackage

test/packages/TestPackage/0.2.0/src/TestPackage.jl

@@ -4,4 +4,10 @@ import Example
 
 greet() = print(Example.hello("0.2.0!"))
 
+struct IntType
+    i::Int
+end
+
+const INT_VALUE = IntType(42)
+
 end # module TestPackage