rake-compiler-dock 1.9.1 → 1.11.0.rc1

data/Rakefile

@@ -8,10 +8,30 @@ CLEAN.include("tmp")
 
 RakeCompilerDock::GemHelper.install_tasks
 
+def build_mri_images(platforms, host_platforms, output: )
+  plats = host_platforms.map(&:first).join(",")
+  platforms.each do |platform, _|
+    sdf = "tmp/docker/Dockerfile.mri.#{platform}"
+    image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
+
+    tags = [image_name]
+    tags << image_name.sub("linux-gnu", "linux") if image_name.include?("linux-gnu")
+    RakeCompilerDock.docker_build(sdf, tag: tags, platform: plats, output: output)
+  end
+end
+
+def build_jruby_images(host_platforms, output: )
+  image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
+  plats = host_platforms.map(&:first).join(",")
+  sdf = "tmp/docker/Dockerfile.jruby"
+  RakeCompilerDock.docker_build(sdf, tag: image_name, platform: plats, output: output)
+end
+
 platforms = [
   # tuple is [platform, target]
   ["aarch64-linux-gnu", "aarch64-linux-gnu"],
   ["aarch64-linux-musl", "aarch64-linux-musl"],
+  ["aarch64-mingw-ucrt", "aarch64-w64-mingw32"],
   ["arm-linux-gnu", "arm-linux-gnueabihf"],
   ["arm-linux-musl", "arm-linux-musleabihf"],
   ["arm64-darwin", "aarch64-apple-darwin"],
@@ -25,51 +45,138 @@ platforms = [
   ["x86_64-linux-musl", "x86_64-unknown-linux-musl"],
 ]
 
+host_platforms = [
+  # tuple is [docker platform, RUBY_PLATFORM matcher]
+  ["linux/amd64", /^x86_64|^x64|^amd64/],
+  ["linux/arm64", /^aarch64|arm64/],
+]
+local_platform = host_platforms.find { |_,reg| reg =~ RUBY_PLATFORM } or
+    raise("RUBY_PLATFORM #{RUBY_PLATFORM} is not supported as host")
+
+mkdir_p "tmp/docker"
+
+docker_platform, _ = local_platform
+platforms.each do |platform, target|
+  sdf = "tmp/docker/Dockerfile.mri.#{platform}"
+  df = ERB.new(File.read("Dockerfile.mri.erb"), trim_mode: ">").result(binding)
+  File.write(sdf, df)
+  CLEAN.include(sdf)
+end
+sdf = "tmp/docker/Dockerfile.jruby"
+df = File.read("Dockerfile.jruby")
+File.write(sdf, df)
+
+parallel_docker_build = RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "tmp/docker/Dockerfile.mri.#{pl}" } + ["tmp/docker/Dockerfile.jruby"], workdir: "tmp/docker", task_prefix: "common-")
+
 namespace :build do
+  parallel_docker_build.define_file_tasks platform: docker_platform
+
+  # The jobs in the CI pipeline are already organized in a tree structure.
+  # So we can avoid unnecessary rebuilds by omitting the dependecies.
+  unless ENV['RCD_TASK_DEPENDENCIES'] = "false"
+    parallel_docker_build.define_tree_tasks
+    parallel_docker_build.define_final_tasks
+  end
 
   platforms.each do |platform, target|
-    sdf = "Dockerfile.mri.#{platform}"
-
-    desc "Build image for platform #{platform}"
-    task platform => sdf
-    task sdf do
-      image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
-      sh(*RakeCompilerDock.docker_build_cmd(platform), "-t", image_name, "-f", "Dockerfile.mri.#{platform}", ".")
-      if image_name.include?("linux-gnu")
-        sh("docker", "tag", image_name, image_name.sub("linux-gnu", "linux"))
-      end
-    end
+    sdf = "tmp/docker/Dockerfile.mri.#{platform}"
 
-    df = ERB.new(File.read("Dockerfile.mri.erb"), trim_mode: ">").result(binding)
-    File.write(sdf, df)
-    CLEAN.include(sdf)
+    # Load image after build on local platform only
+    desc "Build and load image for platform #{platform} on #{docker_platform}"
+    task platform => sdf do
+      build_mri_images([platform], [local_platform], output: 'load')
+    end
+    multitask :images => platform
   end
 
-  desc "Build image for JRuby"
-  task :jruby => "Dockerfile.jruby"
-  task "Dockerfile.jruby" do
-    image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
-    sh(*RakeCompilerDock.docker_build_cmd("jruby"), "-t", image_name, "-f", "Dockerfile.jruby", ".")
+  sdf = "tmp/docker/Dockerfile.jruby"
+  # Load image after build on local platform only
+  desc "Build and load image for JRuby on #{docker_platform}"
+  task :jruby => sdf do
+    build_jruby_images([local_platform], output: 'load')
   end
+  multitask :images => :jruby
 
-  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "Dockerfile.mri.#{pl}" } + ["Dockerfile.jruby"], workdir: "tmp/docker")
-
+  all_mri_images = platforms.map(&:first)
   desc "Build images for all MRI platforms in parallel"
   if ENV['RCD_USE_BUILDX_CACHE']
-    task :mri => platforms.map(&:first)
+    task :mri => all_mri_images
   else
-    multitask :mri => platforms.map(&:first)
+    multitask :mri => all_mri_images
   end
 
+  all_images = all_mri_images + ["jruby"]
   desc "Build images for all platforms in parallel"
   if ENV['RCD_USE_BUILDX_CACHE']
-    task :all => platforms.map(&:first) + ["jruby"]
+    task :images => all_images
   else
-    multitask :all => platforms.map(&:first) + ["jruby"]
+    multitask :images => all_images
   end
 end
 
-task :build => "build:all"
+namespace :release do
+  host_pl = host_platforms.map(&:first).join(",")
+
+  desc "Push image for JRuby on #{host_pl}"
+  task :jruby do
+    build_jruby_images(host_platforms, output: 'push')
+  end
+
+  desc "Push all docker images on #{host_pl}"
+  multitask :images => :jruby
+
+  platforms.each do |platform, target|
+    desc "Push image for platform #{platform} on #{host_pl}"
+    task platform do
+      build_mri_images([platform], host_platforms, output: 'push')
+    end
+
+    desc "Push all docker images on #{host_pl}"
+    multitask :images => platform
+  end
+
+  desc "Show download sizes of the release images"
+  task :sizes do
+    require "yaml"
+
+    ths = platforms.map do |pl, _|
+      image_name = RakeCompilerDock::Starter.container_image_name(platform: pl)
+      Thread.new do
+        [ pl,
+          IO.popen("docker manifest inspect #{image_name} -v", &:read)
+        ]
+      end
+    end
+
+    hlayers = Hash.new{|h,k| h[k] = {} }
+    isize_sums = Hash.new{|h,k| h[k] = 0 }
+
+    ths.map(&:value).each do |pl, ystr|
+      y = YAML.load(ystr)
+      y = [y] unless y.is_a?(Array)
+      y.each do |img|
+        next unless img
+        host_pl = "#{img.dig("Descriptor", "platform", "architecture")}-#{
+        img.dig("Descriptor", "platform", "os")}"
+        next if host_pl=="unknown-unknown"
+        lays = img.dig("OCIManifest", "layers") || img.dig("SchemaV2Manifest", "layers")
+        isize = lays.map do |lay|
+          hlayers[host_pl][lay["digest"]] = lay["size"]
+        end.sum
+        isize_sums[host_pl] += isize
+        puts format("%-15s %-20s:%12d MB", host_pl, pl, isize/1024/1024)
+      end
+    end
+    puts "----------"
+    isize_sums.each do |host_pl, isize|
+      puts format("%-15s %-20s:%12d MB", host_pl, "all-separate", isize/1024/1024)
+    end
+    hlayers.each do |host_pl, layers|
+      asize = layers.values.sum
+      puts format("%-15s %-20s:%12d MB", host_pl, "all-combined", asize/1024/1024)
+    end
+  end
+end
 
 namespace :prepare do
   desc "Build cross compiler for x64-mingw-ucrt aka RubyInstaller-3.1+"
@@ -114,19 +221,15 @@ task :update_lists do
   end
 end
 
-namespace :release do
-  desc "push all docker images"
-  task :images do
-    image_name = RakeCompilerDock::Starter.container_image_name(rubyvm: "jruby")
-    sh("docker", "push", image_name)
-
-    platforms.each do |platform, _|
-      image_name = RakeCompilerDock::Starter.container_image_name(platform: platform)
-      sh("docker", "push", image_name)
-
-      if image_name.include?("linux-gnu")
-        sh("docker", "push", image_name.sub("linux-gnu", "linux"))
-      end
-    end
+desc "Update CI publish workflows from erb"
+namespace :ci do
+  task :update_workflows do
+    erb = ERB.new(File.read(".github/workflows/publish-images.yml.erb"))
+    sdf = ".github/workflows/publish-images.yml"
+    release = false
+    File.write(sdf, erb.result(binding))
+    sdf = ".github/workflows/release-images.yml"
+    release = true
+    File.write(sdf, erb.result(binding))
   end
 end

data/build/buildkitd.toml

@@ -0,0 +1,2 @@
+[worker.oci]
+  gc = false

data/build/gem_helper.rb

@@ -13,11 +13,11 @@ module RakeCompilerDock
     end
 
     def hfile
-      "History.md"
+      "CHANGELOG.md"
     end
 
     def headline
-      '([^\w]*)(\d+\.\d+\.\d+)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
+      '([^\w]*)(\d+\.\d+\.\d+(?:\.\w+)?)([^\w]+)([2Y][0Y][0-9Y][0-9Y]-[0-1M][0-9M]-[0-3D][0-9D])([^\w]*|$)'
     end
 
     def reldate

data/build/mk_musl_cross.sh

@@ -29,7 +29,7 @@ GCC_CONFIG += --disable-libquadmath --disable-decimal-float
 GCC_CONFIG += --disable-multilib
 EOF
 
-make -j$(nproc) install
+make -j$(nproc) install LINUX_HEADERS_SITE=http://mirrors.2f30.org/sabotage/tarballs/
 
 popd
 

data/build/parallel_docker_build.rb

@@ -9,21 +9,37 @@ module RakeCompilerDock
         if platform
           cache_version = RakeCompilerDock::IMAGE_VERSION.split(".").take(2).join(".")
           cache = File.join("cache", cache_version, platform)
-          "docker buildx build --cache-to=type=local,dest=#{cache},mode=max --cache-from=type=local,src=#{cache} --load"
+          "docker buildx build --cache-to=type=local,dest=#{cache},mode=max --cache-from=type=local,src=#{cache} --progress=plain"
         else
           return nil
         end
       else
-        ENV['RCD_DOCKER_BUILD'] || "docker build"
+        ENV['RCD_DOCKER_BUILD'] || "docker buildx build --progress=plain"
       end
       Shellwords.split(cmd)
     end
+
+    # Run an intermediate dockerfile without tag
+    #
+    # The layers will be reused in subsequent builds, even if they run in parallel.
+    def docker_build(filename, tag: nil, output: false, platform: )
+      cmd = docker_build_cmd(platform)
+      return if cmd.nil?
+      tag_args = Array(tag).flat_map{|t| ["-t", t] } if tag
+      push_args = ["--push"] if output == 'push'
+      push_args = ["--load"] if output == 'load'
+      Class.new.extend(FileUtils).sh(*cmd, "-f", filename, ".", "--platform", platform, *tag_args, *push_args)
+    end
   end
 
   # Run docker builds in parallel, but ensure that common docker layers are reused
   class ParallelDockerBuild
     include Rake::DSL
 
+    attr_reader :file_deps
+    attr_reader :tree_deps
+    attr_reader :final_deps
+
     def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-")
       FileUtils.mkdir_p(workdir)
 
@@ -33,7 +49,11 @@ module RakeCompilerDock
       vcs = find_commons(files)
       # pp vcs
 
-      define_common_tasks(vcs, workdir, task_prefix)
+      @file_deps = {}
+      @tree_deps = {}
+      @final_deps = {}
+
+      write_docker_files(vcs, workdir, task_prefix)
     end
 
     # Read given dockerfiles from inputdir and split into a list of commands.
@@ -87,36 +107,57 @@ module RakeCompilerDock
       end.compact.to_h
     end
 
-    # Write intermediate dockerfiles to workdir and define rake tasks
-    #
-    # The rake tasks are named after the dockerfiles given to #new .
-    # This also adds dependant intermediate tasks as prerequisites.
-    def define_common_tasks(vcs, workdir, task_prefix, plines=[])
+    # Write intermediate dockerfiles to workdir and fill properties
+    def write_docker_files(vcs, workdir, task_prefix, plines=[])
       vcs.map do |files, (lines, nvcs)|
-        fn = "#{task_prefix}#{Digest::SHA1.hexdigest(files.join)}"
-        File.write(File.join(workdir, fn), (plines + lines).join)
-        task fn do
-          docker_build(fn, workdir)
+        fn = "#{task_prefix}#{Digest::SHA1.hexdigest(files.join)[0, 7]}"
+        wfn = File.join(workdir, fn)
+        File.write(wfn, (plines + lines).join)
+        @file_deps[fn] = wfn
+
+        files.each do |file|
+          @final_deps[file] = fn
         end
 
-        nfn = define_common_tasks(nvcs, workdir, task_prefix, plines + lines)
+        nfn = write_docker_files(nvcs, workdir, task_prefix, plines + lines)
         nfn.each do |file|
-          task file => fn
-        end
-        files.each do |file|
-          task file => fn
+          @tree_deps[file] = fn
         end
         fn
       end
     end
 
-    # Run an intermediate dockerfile without tag
+    # Define rake tasks for building common docker files
     #
-    # The layers will be reused in subsequent builds, even if they run in parallel.
-    def docker_build(filename, workdir)
-      cmd = RakeCompilerDock.docker_build_cmd
-      return if cmd.nil?
-      sh(*RakeCompilerDock.docker_build_cmd, "-f", File.join(workdir, filename), ".")
+    # The rake tasks are named after the dockerfiles given to #new .
+    # This also adds dependant intermediate tasks as prerequisites.
+    def define_rake_tasks(**build_options)
+      define_file_tasks(**build_options)
+      define_tree_tasks
+      define_final_tasks
+    end
+
+    def define_file_tasks(**build_options)
+      file_deps.each do |fn, wfn|
+        # p file_deps: {fn => wfn}
+        task fn do
+          RakeCompilerDock.docker_build(wfn, **build_options)
+        end
+      end
+    end
+
+    def define_tree_tasks
+      tree_deps.each do |file, prereq|
+        # p tree_deps: {file => prereq}
+        task file => prereq
+      end
+    end
+
+    def define_final_tasks
+      final_deps.each do |file, prereq|
+        # p final_deps: {file => prereq}
+        task file => prereq
+      end
     end
   end
 end

data/build/patches/{rake-compiler-1.2.9 → rake-compiler-1.3.1}/0004-Enable-build-of-static-libruby.patch

@@ -1,17 +1,19 @@
 diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
-index 8317a2a3..8ed21718 100644
+index d37ab97b..4623896a 100644
 --- a/tasks/bin/cross-ruby.rake
 +++ b/tasks/bin/cross-ruby.rake
-@@ -116,11 +116,30 @@
+@@ -116,11 +116,32 @@
          "--host=#{mingw_host}",
          "--target=#{mingw_target}",
          "--build=#{RUBY_BUILD}",
 -        '--enable-shared',
 +        '--enable-install-static-library',
 +        '--disable-jit-support',
++        '--disable-rpath',
 +        'ac_cv_lib_z_uncompress=no',
 +        'ac_cv_lib_crypt_crypt=no',
 +        'ac_cv_func_crypt_r=no',
++        'extra_warnflags=-Wno-shorten-64-to-32 -Wno-dll-attribute-on-redeclaration',
          '--disable-install-doc',
          '--with-ext=',
        ]

data/build/patches/{rake-compiler-1.2.9 → rake-compiler-1.3.1}/0005-build-miniruby-first.patch

@@ -1,12 +1,11 @@
 diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
-index d37ab97b..0df44b30 100644
+index d37ab97b..512afbf4 100644
 --- a/tasks/bin/cross-ruby.rake
 +++ b/tasks/bin/cross-ruby.rake
-@@ -129,6 +129,12 @@
+@@ -129,6 +129,11 @@
  
      # make
      file "#{build_dir}/ruby.exe" => ["#{build_dir}/Makefile"] do |t|
-+      puts "MIKE: #{ruby_cc_version}: #{mingw_target}"
 +      if ruby_cc_version.start_with?("ruby-3.1") && mingw_target =~ /darwin/
 +        # for later 3.1.x releases, we need to explicitly build miniruby
 +        # see https://bugs.ruby-lang.org/issues/19239

data/build/patches/rake-compiler-1.3.1/0006-ruby-4-rubyspec-capiext.patch

@@ -0,0 +1,16 @@
+diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
+index 3d23eed6..904c12e0 100644
+--- a/tasks/bin/cross-ruby.rake
++++ b/tasks/bin/cross-ruby.rake
+@@ -150,6 +150,11 @@
+ 
+     # make
+     file "#{build_dir}/ruby.exe" => ["#{build_dir}/Makefile"] do |t|
++      if ruby_cc_version.start_with?("ruby-4.0")
++        # https://bugs.ruby-lang.org/issues/21792 - hopefully will be fixed by 4.0.0 final
++        FileUtils.rm_f("#{USER_HOME}/sources/#{ruby_cc_version}/spec/ruby/optional/capi/ext/digest_spec.c")
++      end
++
+       if ruby_cc_version.start_with?("ruby-3.1") && mingw_target =~ /darwin/
+         # for later 3.1.x releases, we need to explicitly build miniruby
+         # see https://bugs.ruby-lang.org/issues/19239

data/build/sudoers

@@ -1 +1 @@
-Defaults        env_keep += "http_proxy https_proxy ftp_proxy GEM_PRIVATE_KEY_PASSPHRASE RCD_HOST_RUBY_PLATFORM RCD_HOST_RUBY_VERSION RCD_IMAGE RUBY_CC_VERSION LD_LIBRARY_PATH DEVTOOLSET_ROOTPATH SOURCE_DATE_EPOCH"
+Defaults        env_keep += "http_proxy https_proxy ftp_proxy GEM_PRIVATE_KEY_PASSPHRASE RCD_HOST_RUBY_PLATFORM RCD_HOST_RUBY_VERSION RCD_IMAGE RUBY_CC_VERSION LD_LIBRARY_PATH DEVTOOLSET_ROOTPATH SOURCE_DATE_EPOCH RBENV_VERSION"

data/lib/rake_compiler_dock/starter.rb

@@ -41,6 +41,11 @@ module RakeCompilerDock
         user = options.fetch(:username){ current_user }
         group = options.fetch(:groupname){ current_group }
 
+        ruby_version = options[:ruby] || ENV['RCD_RUBY_VERSION']
+        rbenv_opts = if ruby_version
+          ["-e", "RBENV_VERSION=#{ruby_version}"]
+        end
+
         platforms(options).split(" ").each do |platform|
           image_name = container_image_name(options.merge(platform: platform))
 
@@ -73,6 +78,7 @@ module RakeCompilerDock
               "-e", "RCD_HOST_RUBY_PLATFORM=#{RUBY_PLATFORM}",
               "-e", "RCD_HOST_RUBY_VERSION=#{RUBY_VERSION}",
               "-e", "RCD_IMAGE=#{image_name}",
+              *rbenv_opts,
               "-w", make_valid_path(workdir),
               *docker_opts,
               image_name,
@@ -167,7 +173,7 @@ module RakeCompilerDock
 
           "%s/rake-compiler-dock-image:%s-%s%s" % [
             container_registry,
-            options.fetch(:version) { IMAGE_VERSION },
+            options.fetch(:version) { image_version },
             container_rubyvm(options),
             container_jrubyvm?(options) ? "" : "-#{options.fetch(:platform)}",
           ]
@@ -178,6 +184,10 @@ module RakeCompilerDock
         ENV['CONTAINER_REGISTRY'] || "ghcr.io/rake-compiler"
       end
 
+      def image_version
+        ENV['RCD_IMAGE_VERSION'] || IMAGE_VERSION
+      end
+
       def container_rubyvm(options={})
         return "jruby" if options[:platform] == "jruby"
         options.fetch(:rubyvm) { ENV['RCD_RUBYVM'] } || "mri"

data/lib/rake_compiler_dock/version.rb

@@ -1,4 +1,4 @@
 module RakeCompilerDock
-  VERSION = "1.9.1"
-  IMAGE_VERSION = "1.9.1"
+  VERSION = "1.11.0.rc1"
+  IMAGE_VERSION = "1.11.0.rc1"
 end

data/lib/rake_compiler_dock.rb

@@ -82,28 +82,23 @@ module RakeCompilerDock
   #
   #   RakeCompilerDock.cross_rubies
   #   # => {
-  #   #      "3.4" => "3.4.1",
-  #   #      "3.3" => "3.3.5",
-  #   #      "3.2" => "3.2.6",
-  #   #      "3.1" => "3.1.6",
+  #   #      "3.4" => "3.4.8",
+  #   #      "3.3" => "3.3.10",
+  #   #      "3.2" => "3.2.9",
+  #   #      "3.1" => "3.1.7",
   #   #      "3.0" => "3.0.7",
   #   #      "2.7" => "2.7.8",
-  #   #      "2.6" => "2.6.10",
-  #   #      "2.5" => "2.5.9",
-  #   #      "2.4" => "2.4.10",
   #   #    }
   #
   def cross_rubies
     {
-      "3.4" => "3.4.1",
-      "3.3" => "3.3.7",
-      "3.2" => "3.2.6",
-      "3.1" => "3.1.6",
+      "4.0" => "4.0.0",
+      "3.4" => "3.4.8",
+      "3.3" => "3.3.10",
+      "3.2" => "3.2.9",
+      "3.1" => "3.1.7",
       "3.0" => "3.0.7",
       "2.7" => "2.7.8",
-      "2.6" => "2.6.10",
-      "2.5" => "2.5.9",
-      "2.4" => "2.4.10",
     }
   end
 
@@ -118,13 +113,13 @@ module RakeCompilerDock
   #
   # For example:
   #   RakeCompilerDock.ruby_cc_version("2.7", "3.4")
-  #   # => "3.4.1:2.7.8"
+  #   # => "3.4.8:2.7.8"
   #
   #   RakeCompilerDock.ruby_cc_version("~> 3.2")
-  #   # => "3.4.1:3.3.7:3.2.6"
+  #   # => "3.4.8:3.3.10:3.2.9"
   #
   #   RakeCompilerDock.ruby_cc_version(Gem::Requirement.new("~> 3.2"))
-  #   # => "3.4.1:3.3.7:3.2.6"
+  #   # => "3.4.8:3.3.10:3.2.9"
   #
   def ruby_cc_version(*requirements)
     cross = cross_rubies

data/mingw64-ucrt/README.md

@@ -12,47 +12,3 @@ They are built by the following command:
 ```sh
 docker buildx build . -t larskanis/mingw64-ucrt:20.04 --platform linux/arm64,linux/amd64 --push
 ```
-
-
-Create builder instance for two architectures
-------------------
-
-Building with qemu emulation fails currently with a segfault, so that it must be built by a builder instance with at least one remote node for the other architecture.
-Building on native hardware is also much faster (~30 minutes) than on qemu.
-A two-nodes builder requires obviously a ARM and a Intel/AMD device.
-It can be created like this:
-
-```sh
-# Make sure the remote instance can be connected
-$ docker -H ssh://isa info
-
-# Create a new builder with the local instance
-$ docker buildx create --name isayoga
-
-# Add the remote instance
-$ docker buildx create --name isayoga --append ssh://isa
-
-# They are inactive from the start
-$ docker buildx ls
-NAME/NODE      DRIVER/ENDPOINT                   STATUS     BUILDKIT   PLATFORMS
-isayoga        docker-container
- \_ isayoga0    \_ unix:///var/run/docker.sock   inactive
- \_ isayoga1    \_ ssh://isa                     inactive
-default*       docker
- \_ default     \_ default                       running    v0.13.2    linux/arm64
-
-# Bootstrap the instances
-$ docker buildx inspect --bootstrap --builder isayoga
-
-# Set the new builder as default
-$ docker buildx use isayoga
-
-# Now it should be default and in state "running"
-$ docker buildx ls
-NAME/NODE      DRIVER/ENDPOINT                   STATUS    BUILDKIT   PLATFORMS
-isayoga*       docker-container
- \_ isayoga0    \_ unix:///var/run/docker.sock   running   v0.18.2    linux/arm64
- \_ isayoga1    \_ ssh://isa                     running   v0.18.2    linux/amd64, linux/amd64/v2, linux/amd64/v3, linux/386
-default        docker
- \_ default     \_ default                       running   v0.13.2    linux/arm64
-```

data/test/env/Dockerfile.alpine

@@ -2,7 +2,7 @@ ARG from_image
 FROM ${from_image}
 
 RUN uname -a
-RUN apk add ruby ruby-etc ruby-rake git
+RUN apk add ruby ruby-rake git
 
 RUN ruby --version
 RUN gem env

data/test/fixtures/mig_test_rpc.defs

@@ -0,0 +1,8 @@
+#include <mach/std_types.defs>
+#include <mach/mach_types.defs>
+
+subsystem mig_test_ipc 1;
+
+routine mig_test_call(
+                                server_port     : mach_port_t;
+                out             returnvalue     : int);

data/test/rcd_test/Rakefile

@@ -22,6 +22,7 @@ else
       aarch64-linux
       aarch64-linux-gnu
       aarch64-linux-musl
+      aarch64-mingw-ucrt
       arm-linux
       arm-linux-gnu
       arm-linux-musl

data/test/rcd_test/ext/mri/extconf.rb

@@ -18,6 +18,8 @@ else
   puts "cc --version: #{ %x[#{CONFIG['CC']} --version].lines.first}"
   puts "-"*70
 
+  $CFLAGS << " -Wall -Werror"
+
   have_func('rb_thread_call_without_gvl', 'ruby/thread.h') ||
       raise("rb_thread_call_without_gvl() not found")
 

data/test/rcd_test/rcd_test.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.summary       = "C extension for testing rake-compiler-dock"
   spec.description   = "This gem has no real use other than testing builds of binary gems."
   spec.homepage      = "https://github.com/rake-compiler/rake-compiler-dock"
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.required_ruby_version = ">= 2.7.0"
   spec.license = "MIT"
 
   spec.files = [

data/test/rcd_test/test/test_basic.rb

@@ -35,4 +35,15 @@ class TestBasic < Minitest::Test
     is_linux = RUBY_PLATFORM.include?("linux")
     assert_equal(is_linux, RcdTest.largefile_op_removed_from_musl)
   end
+
+  def test_disabled_rpath
+    skip("jruby uses jar files without rpath") if RUBY_ENGINE == "jruby"
+
+    cext_fname = $LOADED_FEATURES.grep(/rcd_test_ext/).first
+    refute_nil(cext_fname, "the C-ext should be loaded")
+    cext_text = File.binread(cext_fname)
+    assert_match(/Init_rcd_test_ext/, cext_text, "C-ext shoud contain the init function")
+    refute_match(/usr\/local/, cext_text, "there should be no rpath to /usr/local/rake-compiler/ruby/x86_64-unknown-linux-musl/ruby-3.4.5/lib or so")
+    refute_match(/home\//, cext_text, "there should be no path to /home/ or so")
+  end
 end