tebako 0.15.2 → 0.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40cccec56036f14133e05046f858915c7f6ae657c11f3560b647d791c2cc952a
-  data.tar.gz: 79022b3acb1d0457a996f671ca93e69ac024107156f31445f27159a1d81ac7da
+  metadata.gz: 8ec3da7722b76d52f17d341664974ff8ea5f5164feec924958cd2725238439d0
+  data.tar.gz: 2e244d8b29c27a4f884aa969961dca6968323d21376012bf539dbce28c5b7baa
 SHA512:
-  metadata.gz: 318cab0bce4b6528efe1e1c215b473344311f68fcef2bc7ac379cdc81248c06afac942fff0b55a9dd5e45b88f5989031597ef633c4e6e6d69ed2478a83138b13
-  data.tar.gz: 0f3b13569b1ffd26de43d6233bfb2579fe91e1d6107b51370562c64e2f0f87021813bb1129eaafaae9f68202e0c37d9d03cf9d439ce5610ff857493278fe6838
+  metadata.gz: ccf67b3e4bf6444ca31627b27e9876699f743cdac01e2ebea0cee29a9ea8113d24d5ef34d6b15ebd8461620c8e29bb3d75ef7332b5a1934e3b3d579130cdb871
+  data.tar.gz: 51695b16c05b1063678bc2f4c6042ae65c3111799f14f81a5d3982a30c4f94f74f7f28d2fa587c11cdcf509ff9a5f105428ed95eff693d47377337980d349177

data/CMakeLists.txt

@@ -217,6 +217,7 @@ endif()
 def_ext_prj_g(PATCHELF "65e14792061c298f1d2bc44becd48a10cbf0bc81")
 
 set(LIBYAML_RUBY_OPTION "")
+set(RUBY_LIBS "")
 if(${RUBY_VER} VERSION_LESS "3.2.0")
   set(LIBYAML_RUBY_OPTION "--enable-bundled-libyaml")
 endif(${RUBY_VER} VERSION_LESS "3.2.0")
@@ -397,6 +398,16 @@ else(IS_DARWIN)
   if(RB_W32)
     string(CONCAT RUBY_C_FLAGS ${RUBY_C_FLAGS} " -DRB_W32=1")
     string(CONCAT RUBY_L_FLAGS ${RUBY_L_FLAGS} " -l:libstdc++.a -L${TLIBD}")
+    # vcpkg's static libcrypto.a (the CAPI engine, e_capi.obj) references
+    # the CryptoAPI certificate store (CertFreeCertificateContext & co.),
+    # but ruby's default mingw $LIBS lack -lcrypt32, so every ext/openssl
+    # have_func link probe failed with undefined Cert* references and the
+    # OpenSSL-1.1.0 accessor fallbacks in openssl_missing.c compiled
+    # against opaque 3.x structs (tebako#345). mkmf appends $LIBS after
+    # -lssl/-lcrypto, so LIBS here lands in the right order for static
+    # linking; advapi32/user32 cover the rest of the usual static-openssl
+    # system-lib tail.
+    set(RUBY_LIBS "-lcrypt32 -ladvapi32 -luser32")
     set(C_FLAGS_DEST cppflags)
   endif(RB_W32)
 
@@ -432,7 +443,8 @@ ExternalProject_Add(${RUBY_PRJ}
                                                         --with-out-ext=${RUBY_WITHOUT_EXT}    \
                                                         --prefix=${DATA_SRC_DIR}              \
                                                         ${C_FLAGS_DEST}=\"${RUBY_C_FLAGS}\"   \
-                                                        LDFLAGS=\"${RUBY_L_FLAGS}\""
+                                                        LDFLAGS=\"${RUBY_L_FLAGS}\"              \
+                                                        LIBS=\"${RUBY_LIBS}\""
   COMMAND   ruby ${EXE}/tebako-packager pass2 ${OSTYPE_TXT} ${RUBY_SOURCE_DIR} ${DEPS_LIB_DIR} ${DATA_SRC_DIR} ${RUBY_STASH_DIR} ${RUBY_VER}
   INSTALL_COMMAND  ""
 )

data/include/tebako/tpkg.h

@@ -50,7 +50,7 @@
  *        8     8    u64 size   (image length in bytes)
  *       16     4    u32 format_id (0=auto(magic), 1=dwarfs, 2=squashfs, 3=zip, 4=runtime payload)
  *       20     4    u32 flags
- *       24   256    char mount_point[256] (UTF-8, NUL-padded; empty for runtime payloads)
+ *       24   256    char mount_point[256] (UTF-8, NUL-padded)
  *
  * Reader algorithm: read the fixed-size header at EOF - TPKG_HEADER_SIZE,
  * check the magic, verify header_crc32, then read slot_count slot records at
@@ -97,8 +97,8 @@ extern "C" {
 #define TPKG_MOUNT_POINT_LEN 256u
 #define TPKG_RUNTIME_REF_LEN 128u
 #define TPKG_MAGIC "TEBAKOTFS"
-#define TPKG_MAGIC_LEN 10u        /* including the terminating NUL */
-#define TPKG_MAGIC_PREFIX_LEN 4u  /* "TEBA": absent-vs-corrupt discriminator */
+#define TPKG_MAGIC_LEN 10u       /* including the terminating NUL */
+#define TPKG_MAGIC_PREFIX_LEN 4u /* "TEBA": absent-vs-corrupt discriminator */
 
 /* package_flags */
 #define TPKG_FLAG_LEAN 0x1u
@@ -108,8 +108,8 @@ extern "C" {
 #define TPKG_FORMAT_DWARFS 1u
 #define TPKG_FORMAT_SQUASHFS 2u
 #define TPKG_FORMAT_ZIP 3u
-/* runtime payload slot of a fat package: the bootstrap installs it into the
- * shared cache at first run; it is never mounted as a filesystem image */
+/* A runtime payload slot (fat packages): the compressed language-runtime
+ * package the bootstrap installs into the shared cache on first run. */
 #define TPKG_FORMAT_RUNTIME 4u
 
 /* ---- error codes (returned by tpkg_errno) -------------------------------- */
@@ -223,19 +223,12 @@ enum {
 };
 
 /* slot record field offsets */
-enum {
-  TPKG__REC_OFFSET = 0,
-  TPKG__REC_SIZE = 8,
-  TPKG__REC_FORMAT = 16,
-  TPKG__REC_FLAGS = 20,
-  TPKG__REC_MOUNT = 24
-};
+enum { TPKG__REC_OFFSET = 0, TPKG__REC_SIZE = 8, TPKG__REC_FORMAT = 16, TPKG__REC_FLAGS = 20, TPKG__REC_MOUNT = 24 };
 
 /* wire sizes are fixed by the format; catch exotic padding at compile time */
 typedef char tpkg__assert_slot_size[(sizeof(tpkg_slot) == TPKG_SLOT_SIZE) ? 1 : -1];
-typedef char tpkg__assert_manifest_size[(sizeof(tpkg_manifest) ==
-                                         4 * sizeof(uint32_t) + TPKG_RUNTIME_REF_LEN +
-                                             TPKG_MAX_SLOTS * sizeof(tpkg_slot))
+typedef char tpkg__assert_manifest_size[(sizeof(tpkg_manifest) == 4 * sizeof(uint32_t) + TPKG_RUNTIME_REF_LEN +
+                                                                      TPKG_MAX_SLOTS * sizeof(tpkg_slot))
                                             ? 1
                                             : -1];
 

data/lib/tebako/cli_helpers.rb

@@ -112,7 +112,8 @@ module Tebako
     def do_press_prebuilt(options_manager, scenario_manager)
       Tebako::Packager.check_prebuilt_env!(options_manager.stash_dir, options_manager.deps_bin_dir)
       runtime_path = Tebako::RuntimeManager.resolve(options_manager.ruby_ver, options_manager.host_platform)
-      app_image = Tebako::Packager.build_app_image(options_manager, scenario_manager)
+      app_image = Tebako::Packager.build_app_image(options_manager, scenario_manager,
+                                                   Tebako::RuntimeManager.layout(runtime_path))
 
       images = [{ path: app_image, mount_point: scenario_manager.fs_mount_point,
                   format_id: Tebako::Stitcher::FORMAT_DWARFS }] + options_manager.images
@@ -128,33 +129,39 @@ module Tebako
     # slot, so the first run installs it without any network access.
     def do_press_three_part(options_manager, scenario_manager)
       bootstrap_path, runtime_path = resolve_three_part_parts(options_manager)
-      app_image = Tebako::Packager.build_app_image(options_manager, scenario_manager)
-      images = three_part_images(options_manager, scenario_manager, app_image, runtime_path)
+      app_image = Tebako::Packager.build_app_image(options_manager, scenario_manager,
+                                                   Tebako::RuntimeManager.layout(runtime_path))
+      payload_path = options_manager.fat? ? runtime_path : nil
+      images = three_part_images(options_manager, scenario_manager, app_image, payload_path)
       package = "#{options_manager.package}#{scenario_manager.exe_suffix}"
-      runtime_sha256 = runtime_path && Digest::SHA256.file(runtime_path).hexdigest
+      stitch_three_part(options_manager, bootstrap_path, images, package, payload_path)
+      puts "Created tebako #{options_manager.output_type_first} at \"#{package}\""
+    end
+
+    def stitch_three_part(options_manager, bootstrap_path, images, package, payload_path)
       Tebako::Stitcher.stitch(bootstrap_path, images: images, output: package, lean: true,
                                               ruby_version: options_manager.ruby_ver,
                                               launcher_abi: Tebako::LauncherAbi::VERSION,
-                                              runtime_sha256: runtime_sha256)
-      puts "Created tebako #{options_manager.output_type_first} at \"#{package}\""
+                                              runtime_sha256: payload_sha256(payload_path))
+    end
+
+    def payload_sha256(payload_path)
+      payload_path && Digest::SHA256.file(payload_path).hexdigest
     end
 
     # Validate the options and the packaging environment, then resolve the
-    # bootstrap (and, for fat, the runtime payload) into the shared cache
+    # bootstrap and the runtime into the shared cache. The runtime is needed
+    # in both three-part modes: 'fat' embeds it as a payload slot, 'lean'
+    # uses its extracted layout to align the application image's arch
+    # conventions (and references it in the trailer for first-run resolution)
     def resolve_three_part_parts(options_manager)
       options_manager.runtime_source # validates the mode/provenance combination
       check_bootstrap_version!(options_manager)
       Tebako::Packager.check_prebuilt_env!(options_manager.stash_dir, options_manager.deps_bin_dir)
-      runtime_path = fat_runtime_path(options_manager)
+      runtime_path = Tebako::RuntimeManager.resolve(options_manager.ruby_ver, options_manager.host_platform)
       [Tebako::BootstrapManager.resolve(options_manager.host_platform), runtime_path]
     end
 
-    def fat_runtime_path(options_manager)
-      return nil unless options_manager.fat?
-
-      Tebako::RuntimeManager.resolve(options_manager.ruby_ver, options_manager.host_platform)
-    end
-
     def three_part_images(options_manager, scenario_manager, app_image, runtime_path)
       images = [{ path: app_image, mount_point: scenario_manager.fs_mount_point,
                   format_id: Tebako::Stitcher::FORMAT_DWARFS }] + options_manager.images

data/lib/tebako/deploy_helper.rb

@@ -190,7 +190,11 @@ module Tebako
     def configure_commands_not_msys
       @cmd_suffix = ""
       @bat_suffix = ""
-      @force_ruby_platform = "false"
+      # Force the ruby (source) platform for gems: precompiled variants link
+      # against shared system libraries (libffi & co.) that do not exist
+      # inside a tebako package -- e.g. ffi-x86_64-linux-gnu fails to load in
+      # the memfs (tebako#343). msys has always forced this.
+      @force_ruby_platform = "true"
       @nokogiri_option = "--no-use-system-libraries"
     end
 

data/lib/tebako/packager.rb

@@ -129,16 +129,72 @@ module Tebako
       # Deploy the application and build its DwarFS image for stitching onto
       # a prebuilt runtime. Same layout as the bundle-mode image, plus an
       # entry dispatcher at /local/stub.rb (the runtime's compiled-in entry).
-      def build_app_image(options_manager, scenario_manager) # rubocop:disable Metrics/AbcSize
+      # When layout_dir is given (the resolved runtime's extracted layout),
+      # the image's arch conventions are aligned to the runtime's: ruby's
+      # compiled-in search paths come from the runtime build, while the
+      # local packaging environment names arch directories after the press
+      # machine -- on macOS the arch string embeds the kernel version
+      # (arm64-darwin23 vs arm64-darwin24), so they differ whenever press
+      # and runtime were built on different macOS releases.
+      def build_app_image(options_manager, scenario_manager, layout_dir = nil) # rubocop:disable Metrics/AbcSize
         init(options_manager.stash_dir, options_manager.data_src_dir, options_manager.data_pre_dir,
              options_manager.data_bin_dir)
         deploy(options_manager.data_src_dir, options_manager.data_pre_dir, options_manager.rv,
                options_manager.root, scenario_manager.fs_entrance, options_manager.cwd)
+        align_layout_to_runtime!(options_manager.data_src_dir, layout_dir, options_manager.rv) if layout_dir
         write_entry_dispatcher(options_manager.data_src_dir, scenario_manager, options_manager.cwd)
         mkdwarfs(options_manager.deps_bin_dir, options_manager.data_bundle_file, options_manager.data_src_dir)
         options_manager.data_bundle_file
       end
 
+      # Rename the image's arch directories to the runtime's names and drop
+      # in the runtime's own rbconfig.rb. No-op when the conventions already
+      # match (always the case off macOS, where the arch string carries no
+      # OS version).
+      def align_layout_to_runtime!(data_src_dir, layout_dir, ruby_ver)
+        align_stdlib_arch!(data_src_dir, layout_dir, ruby_ver.api_version)
+        align_gem_ext_arch!(data_src_dir, layout_dir, ruby_ver.api_version)
+      end
+
+      def align_stdlib_arch!(data_src_dir, layout_dir, api_ver)
+        runtime_arch = arch_dir_of(File.join(layout_dir, "lib", "ruby", api_ver), "rbconfig.rb")
+        image_arch = arch_dir_of(File.join(data_src_dir, "lib", "ruby", api_ver), "rbconfig.rb")
+        return if runtime_arch.nil? || image_arch.nil? || runtime_arch == image_arch
+
+        puts "   ... aligning app image layout to the runtime (#{image_arch} -> #{runtime_arch})"
+        FileUtils.mv(File.join(data_src_dir, "lib", "ruby", api_ver, image_arch),
+                     File.join(data_src_dir, "lib", "ruby", api_ver, runtime_arch))
+        FileUtils.cp(File.join(layout_dir, "lib", "ruby", api_ver, runtime_arch, "rbconfig.rb"),
+                     File.join(data_src_dir, "lib", "ruby", api_ver, runtime_arch, "rbconfig.rb"))
+      end
+
+      # Native-gem extensions dir uses the dashed flavor of the arch string
+      # (arm64-darwin-23); align it to the runtime's as well
+      def align_gem_ext_arch!(data_src_dir, layout_dir, api_ver)
+        img_ext = File.join(data_src_dir, "lib", "ruby", "gems", api_ver, "extensions")
+        rt_ext = File.join(layout_dir, "lib", "ruby", "gems", api_ver, "extensions")
+        runtime_ext = first_dir(rt_ext)
+        return if runtime_ext.nil? || !Dir.exist?(img_ext)
+
+        Dir.children(img_ext).each do |d|
+          next if d == runtime_ext || !File.directory?(File.join(img_ext, d))
+
+          FileUtils.mv(File.join(img_ext, d), File.join(img_ext, runtime_ext))
+        end
+      end
+
+      def arch_dir_of(dir, marker)
+        return nil unless Dir.exist?(dir)
+
+        Dir.children(dir).find { |d| File.exist?(File.join(dir, d, marker)) }
+      end
+
+      def first_dir(dir)
+        return nil unless Dir.exist?(dir)
+
+        Dir.children(dir).find { |d| File.directory?(File.join(dir, d)) }
+      end
+
       # The prebuilt runtime packages are pressed in 'runtime' mode, so their
       # compiled-in entry point is /local/stub.rb. A stitched package mounts
       # the application image as the root filesystem; the dispatcher written

data/lib/tebako/ruby_version.rb

@@ -46,7 +46,14 @@ module Tebako
       "3.3.6" => "8dc48fffaf270f86f1019053f28e51e4da4cce32a36760a0603a9aee67d7fd8d",
       "3.3.7" => "9c37c3b12288c7aec20ca121ce76845be5bb5d77662a24919651aaf1d12c8628",
       "3.4.1" => "3d385e5d22d368b064c817a13ed8e3cc3f71a7705d7ed1bae78013c33aa7c87f",
-      "3.4.2" => "41328ac21f2bfdd7de6b3565ef4f0dd7543354d37e96f157a1552a6bd0eb364b"
+      "3.4.2" => "41328ac21f2bfdd7de6b3565ef4f0dd7543354d37e96f157a1552a6bd0eb364b",
+      "4.0.0" => "2e8389c8c072cb658c93a1372732d9eac84082c88b065750db1e52a5ac630271",
+      "4.0.1" => "3924be2d05db30f4e35f859bf028be85f4b7dd01714142fd823e4af5de2faf9d",
+      "4.0.2" => "51502b26b50b68df4963336ca41e368cde92c928faf91654de4c4c1791f82aac",
+      "4.0.3" => "77964acc370d5c8375b9502e5ba6c13c03ef91ab9eb9f521c84fb42b9c9a6b0f",
+      "4.0.4" => "f35f6edfa3dabb3f723f9d0cf1906c6512ae77f4e412ab1e68cc6e91d230fa80",
+      "4.0.5" => "7d6149079a63f8ae1d326c9fa65c6019ba2dc3155eae7b39159817911c88958e",
+      "4.0.6" => "837d299e8f7ddf2be31a229a7a7e019d354979825117989acb3b32b1a9be262a"
     }.freeze
 
     MIN_RUBY_VERSION_WINDOWS = "3.1.6"
@@ -72,38 +79,40 @@ module Tebako
       @lib_version ||= "#{@ruby_version.split(".")[0..1].join}0"
     end
 
+    # Version gates compare numerically so 4.x lines fall out naturally
+    # (string indexing broke the moment the major version hit 4)
     def ruby3x?
-      @ruby3x ||= @ruby_version[0] == "3"
+      @ruby3x ||= version_at_least?(3, 0)
     end
 
     def ruby31?
-      @ruby31 ||= ruby3x? && @ruby_version[2].to_i >= 1
+      @ruby31 ||= version_at_least?(3, 1)
     end
 
     def ruby32?
-      @ruby32 ||= ruby3x? && @ruby_version[2].to_i >= 2
+      @ruby32 ||= version_at_least?(3, 2)
     end
 
     def ruby32only?
-      @ruby32only ||= ruby3x? && @ruby_version[2] == "2"
+      @ruby32only ||= major_minor == [3, 2]
     end
 
     def ruby33?
-      @ruby33 ||= ruby3x? && @ruby_version[2].to_i >= 3
+      @ruby33 ||= version_at_least?(3, 3)
     end
 
     def ruby33only?
-      @ruby33only ||= ruby3x? && @ruby_version[2] == "3"
+      @ruby33only ||= major_minor == [3, 3]
     end
 
     def ruby3x7?
       @ruby3x7 ||= ruby34? ||
-                   (ruby33only? && @ruby_version[4].to_i >= 7) ||
-                   (ruby32only? && @ruby_version[4].to_i >= 7)
+                   (ruby33only? && patch_version >= 7) ||
+                   (ruby32only? && patch_version >= 7)
     end
 
     def ruby34?
-      @ruby34 ||= ruby3x? && @ruby_version[2].to_i >= 4
+      @ruby34 ||= version_at_least?(3, 4)
     end
 
     def run_checks
@@ -112,6 +121,22 @@ module Tebako
       version_check_msys
     end
 
+    private
+
+    def major_minor
+      @major_minor ||= @ruby_version.split(".").first(2).map(&:to_i)
+    end
+
+    def patch_version
+      @patch_version ||= @ruby_version.split(".")[2].to_i
+    end
+
+    def version_at_least?(major, minor)
+      (major_minor <=> [major, minor]) >= 0
+    end
+
+    public
+
     def version_check
       return if RUBY_VERSIONS.key?(@ruby_version)
 

data/lib/tebako/runtime_manager.rb

@@ -31,6 +31,7 @@ require "json"
 require "net/http"
 require "uri"
 
+require_relative "build_helpers"
 require_relative "error"
 require_relative "version"
 
@@ -83,6 +84,10 @@ module Tebako
       def resolve(ruby_version, platform, tebako_version: Tebako::VERSION)
         new.resolve(ruby_version, platform, tebako_version: tebako_version)
       end
+
+      def layout(runtime_path)
+        new.layout(runtime_path)
+      end
     end
 
     def initialize(cache_root: nil, mirror: nil, lock_timeout: LOCK_TIMEOUT, retry_delay: RETRY_DELAY)
@@ -105,6 +110,22 @@ module Tebako
       executable
     end
 
+    # Extract the runtime package's filesystem layout next to the cached
+    # package (idempotent) and return the layout root. The layout is the
+    # authoritative source of the runtime's arch conventions (rbconfig
+    # location, gem extension dir naming), which the application image must
+    # match: ruby's compiled-in search paths come from the runtime build,
+    # while a local packaging environment names them after the press machine
+    # (macOS embeds the kernel version, e.g. arm64-darwin23 vs -darwin24).
+    def layout(runtime_path)
+      layout_dir = File.join(File.dirname(runtime_path), "layout")
+      return layout_dir if File.directory?(File.join(layout_dir, "lib"))
+
+      FileUtils.mkdir_p(layout_dir)
+      Tebako::BuildHelpers.run_with_capture_v([runtime_path, "--tebako-extract", layout_dir])
+      layout_dir
+    end
+
     def entries
       base = File.join(@cache_root, cache_subdir)
       return [] unless Dir.exist?(base)

data/lib/tebako/version.rb

@@ -26,5 +26,5 @@
 # POSSIBILITY OF SUCH DAMAGE.
 
 module Tebako
-  VERSION = "0.15.2"
+  VERSION = "0.15.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tebako
 version: !ruby/object:Gem::Version
-  version: 0.15.2
+  version: 0.15.3
 platform: ruby
 authors:
 - Ribose Inc.