rake-compiler-dock 0.7.2 → 1.2.0

data/README.md

@@ -1,8 +1,8 @@
 # rake-compiler-dock
 
-**Easy to use and reliable cross compiler environment for building Windows, Linux and JRuby binary gems.**
+**Easy to use and reliable cross compiler environment for building Windows, Linux, Mac and JRuby binary gems.**
 
-It provides cross compilers and Ruby environments for 2.2 and newer versions of the [RubyInstaller](http://rubyinstaller.org/) and Linux runtime environments.
+It provides cross compilers and Ruby environments for 2.4 and newer versions of the [RubyInstaller](http://rubyinstaller.org/) and Linux runtime environments.
 They are prepared for use with [rake-compiler](https://github.com/rake-compiler/rake-compiler).
 It is used by [many gems with C or JRuby extentions](https://github.com/rake-compiler/rake-compiler-dock/wiki/Projects-using-rake-compiler-dock).
 
@@ -12,11 +12,7 @@ It is also more reliable, since the underlying docker images are versioned and i
 
 ## Installation
 
-Install docker natively on Linux:
-
-    $ sudo apt-get install docker.io
-
-... or install [docker-toolbox for Windows and OSX](https://www.docker.com/docker-toolbox) or boot2docker on [Windows](https://github.com/boot2docker/windows-installer/releases) or [OS X](https://github.com/boot2docker/osx-installer/releases) .
+Install docker [following the instructions on the docker website](https://docs.docker.com/engine/install/) ... or install [docker-toolbox for Windows and OSX](https://github.com/docker/toolbox/releases) or boot2docker on [Windows](https://github.com/boot2docker/windows-installer/releases) or [OS X](https://github.com/boot2docker/osx-installer/releases) .
 
 Install rake-compiler-dock as a gem. The docker image is downloaded later on demand:
 
@@ -34,16 +30,23 @@ Rake-compiler-dock provides the necessary tools to build Ruby extensions for Win
 It is intended to be used in conjunction with [rake-compiler's](https://github.com/rake-compiler/rake-compiler) cross build capability.
 Your Rakefile should enable cross compilation like so:
 
-    Rake::ExtensionTask.new('my_extension', my_gem_spec) do |ext|
-      ext.cross_compile = true
-      ext.cross_platform = %w[x86-mingw32 x64-mingw32 x86-linux x86_64-linux]
-    end
+```ruby
+exttask = Rake::ExtensionTask.new('my_extension', my_gem_spec) do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86-mingw32 x64-mingw-ucrt x64-mingw32 x86-linux x86_64-linux x86_64-darwin arm64-darwin]
+end
+```
+
+See below, how to invoke cross builds in your Rakefile.
 
-It may also be used to build ffi based binary gems like [libusb](https://github.com/larskanis/libusb), but currently doesn't provide any additional build helpers for this use case, beyond docker invocation and cross compilers.
+Additionally it may also be used to build ffi based binary gems like [libusb](https://github.com/larskanis/libusb), but currently doesn't provide any additional build helpers for this use case, beyond docker invocation and cross compilers.
 
 ### Interactive Usage
 
 Rake-compiler-dock offers the shell command `rake-compiler-dock` and a [ruby API](http://www.rubydoc.info/gems/rake-compiler-dock/RakeCompilerDock) for issuing commands within the docker image, described below.
+There are dedicated images for `x86-mingw32`, `x64-mingw-ucrt`, `x64-mingw32`, `x86-linux`, `x86_64-linux`, `x86_64-darwin`, `arm64-darwin` and `jruby` targets.
+The images contain all supported cross ruby versions, with the exception of `x64-mingw32`, which has versions before 3.1 only, and `x64-mingw-ucrt`, which has only ruby-3.1+.
+This is to match the [changed platform of RubyInstaller-3.1](https://rubyinstaller.org/2021/12/31/rubyinstaller-3.1.0-1-released.html).
 
 `rake-compiler-dock` without arguments starts an interactive shell session.
 This is best suited to try out and debug a build.
@@ -55,16 +58,22 @@ But note, that all other changes to the file system of the container are dropped
 All commands are executed with the same user and group of the host.
 This is done by copying user account data into the container and sudo to it.
 
-To build x86 and x64 Windows and Linux binary gems interactively, it can be called like this:
+To build x86 Windows and x86_64 Linux binary gems interactively, it can be called like this:
 
     user@host:$ cd your-gem-dir/
-    user@host:$ rake-compiler-dock   # this enters a container with an interactive shell
+    user@host:$ rake-compiler-dock   # this enters a container with an interactive shell for x86 Windows (default)
     user@5b53794ada92:$ bundle
     user@5b53794ada92:$ rake cross native gem
     user@5b53794ada92:$ exit
     user@host:$ ls pkg/*.gem
-    your-gem-1.0.0.gem  your-gem-1.0.0-x64-mingw32.gem  your-gem-1.0.0-x86-mingw32.gem
-    your-gem-1.0.0-x86_64-linux.gem  your-gem-1.0.0-x86-linux.gem
+    your-gem-1.0.0.gem  your-gem-1.0.0-x86-mingw32.gem
+
+    user@host:$ RCD_PLATFORM=x86_64-linux rake-compiler-dock   # this enters a container for amd64 Linux target
+    user@adc55b2b92a9:$ bundle
+    user@adc55b2b92a9:$ rake cross native gem
+    user@adc55b2b92a9:$ exit
+    user@host:$ ls pkg/*.gem
+    your-gem-1.0.0.gem  your-gem-1.0.0-x86_64-linux.gem
 
 Or non-interactive:
 
@@ -72,13 +81,64 @@ Or non-interactive:
 
 The environment variable `RUBY_CC_VERSION` is predefined as described [below](#environment-variables).
 
-If necessary, additional software from the Ubuntu repositories can be installed, prior to the build command.
-This is local to the running session, only:
+If necessary, additional software can be installed, prior to the build command.
+This is local to the running session, only.
+
+For Windows and Mac:
 
     sudo apt-get update && sudo apt-get install your-package
 
+For Linux:
+
+    sudo yum install your-package
+
 You can also choose between different executable ruby versions by `rvm use <version>` .
-The current default is 2.5.
+The current default is 3.1.
+
+
+### As a CI System Container
+
+The OCI images provided by rake-compiler-dock can be used without the `rake-compiler-dock` gem or wrapper. This may be useful if your CI pipeline is building native gems.
+
+For example, a Github Actions job might look like this:
+
+``` yaml
+jobs:
+  native-gem:
+    name: "native-gem"
+    runs-on: ubuntu-latest
+    container:
+      image: "larskanis/rake-compiler-dock-mri-x86_64-linux:1.2.0"
+    steps:
+      - uses: actions/checkout@v2
+      - run: bundle install && bundle exec rake gem:x86_64-linux:rcd
+      - uses: actions/upload-artifact@v2
+        with:
+          name: native-gem
+          path: gems
+          retention-days: 1
+```
+
+Where the referenced rake task might be defined by:
+
+``` ruby
+cross_platforms = ["x64-mingw32", "x86_64-linux", "x86_64-darwin", "arm64-darwin"]
+
+namespace "gem" do
+  cross_platforms.each do |platform|
+    namespace platform do
+      task "rcd" do
+        Rake::Task["native:#{platform}"].invoke
+        Rake::Task["pkg/#{rcee_precompiled_spec.full_name}-#{Gem::Platform.new(platform)}.gem"].invoke
+      end
+    end
+  end
+end
+
+```
+
+For an example of rake tasks that support this style of invocation, visit https://github.com/flavorjones/ruby-c-extensions-explained/tree/main/precompiled
+
 
 ### JRuby support
 
@@ -102,16 +162,61 @@ To build java binary gems interactively, it can be called like this:
 To make the build process reproducible for other parties, it is recommended to add rake-compiler-dock to your Rakefile.
 This can be done like this:
 
-    task 'gem:native' do
+```ruby
+task 'gem:native' do
+  require 'rake_compiler_dock'
+  sh "bundle package --all"   # Avoid repeated downloads of gems by using gem files from the host.
+  %w[ x86-mingw32 x64-mingw-ucrt x64-mingw32 x86-linux x86_64-linux arm-linux aarch64-linux x86_64-darwin arm64-darwin ].each do |plat|
+    RakeCompilerDock.sh "bundle --local && rake native:#{plat} gem", platform: plat
+  end
+  RakeCompilerDock.sh "bundle --local && rake java gem", rubyvm: :jruby
+end
+```
+
+This runs the `bundle` and `rake` commands once for each platform.
+That is once for the jruby gems and 6 times for the specified MRI platforms.
+
+### Run builds in parallel
+
+rake-compiler-dock uses dedicated docker images per build target (since rake-compiler-dock-1.0).
+Because each target runs in a separate docker container, it is simple to run all targets in parallel.
+The following example defines `rake gem:native` as a multitask and separates the preparation which should run only once.
+It also shows how gem signing can be done with parallel builds.
+Please note, that parallel builds only work reliable, if the specific platform gem is requested (instead of just "rake gem").
+
+```ruby
+  namespace "gem" do
+    task 'prepare' do
       require 'rake_compiler_dock'
-      sh "bundle package"   # Avoid repeated downloads of gems by using gem files from the host.
-      RakeCompilerDock.sh "bundle --local && rake cross native gem"
-      RakeCompilerDock.sh "bundle --local && rake java gem", rubyvm: :jruby
+      require 'io/console'
+      sh "bundle package --all"
+      sh "cp ~/.gem/gem-*.pem build/gem/ || true"
+      ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = STDIN.getpass("Enter passphrase of gem signature key: ")
+    end
+
+    exttask.cross_platform.each do |plat|
+      desc "Build all native binary gems in parallel"
+      multitask 'native' => plat
+
+      desc "Build the native gem for #{plat}"
+      task plat => 'prepare' do
+        RakeCompilerDock.sh <<-EOT, platform: plat
+          (cp build/gem/gem-*.pem ~/.gem/ || true) &&
+          bundle --local &&
+          rake native:#{plat} pkg/#{exttask.gem_spec.full_name}-#{plat}.gem
+        EOT
+      end
     end
+  end
+```
+
+### Add to your Gemfile
 
 Rake-compiler-dock uses [semantic versioning](http://semver.org/), so you should add it into your Gemfile, to make sure, that future changes will not break your build.
 
-    gem 'rake-compiler-dock', '~> 0.7.0'
+```ruby
+gem 'rake-compiler-dock', '~> 1.2'
+```
 
 See [the wiki](https://github.com/rake-compiler/rake-compiler-dock/wiki/Projects-using-rake-compiler-dock) for projects which make use of rake-compiler-dock.
 
@@ -122,14 +227,18 @@ Rake-compiler-dock makes use of several environment variables.
 
 The following variables are recognized by rake-compiler-dock:
 
-* `RCD_RUBYVM` - The flavour of docker image to be used.
+* `RCD_RUBYVM` - The ruby VM and toolchain to be used.
     Must be one of `mri`, `jruby`.
+* `RCD_PLATFORM` - The target rubygems platform.
+    Must be a space separated list out of `x86-mingw32`, `x64-mingw-ucrt`, `x64-mingw32`, `x86-linux`, `x86_64-linux`, `arm-linux`, `aarch64-linux`, `x86_64-darwin` and `arm64-darwin`.
+    It is ignored when `rubyvm` is set to `:jruby`.
 * `RCD_IMAGE` - The docker image that is downloaded and started.
     Defaults to "larskanis/rake-compiler-dock:IMAGE_VERSION" with an image version that is determined by the gem version.
 
 The following variables are passed through to the docker container without modification:
 
 * `http_proxy`, `https_proxy`, `ftp_proxy` - See [Frequently asked questions](https://github.com/rake-compiler/rake-compiler-dock/wiki/FAQ) for more details.
+* `GEM_PRIVATE_KEY_PASSPHRASE` - To avoid interactive password prompts in the container.
 
 The following variables are provided to the running docker container:
 
@@ -137,7 +246,7 @@ The following variables are provided to the running docker container:
 * `RCD_HOST_RUBY_PLATFORM` - The `RUBY_PLATFORM` of the host ruby.
 * `RCD_HOST_RUBY_VERSION` - The `RUBY_VERSION` of the host ruby.
 * `RUBY_CC_VERSION` - The target ruby versions for rake-compiler.
-    The default is defined in the [Dockerfile](https://github.com/rake-compiler/rake-compiler-dock/blob/master/Dockerfile), but can be changed as a parameter to rake.
+    The default is defined in the [Dockerfile](https://github.com/rake-compiler/rake-compiler-dock/blob/94770238d68d71df5f70abe76097451a575ce46c/Dockerfile.mri.erb#L229), but can be changed as a parameter to rake.
 * `RCD_MOUNTDIR` - The directory which is mounted into the docker container.
     Defaults to pwd.
 * `RCD_WORKDIR` - The working directory within the docker container.
@@ -145,7 +254,9 @@ The following variables are provided to the running docker container:
 
 Other environment variables can be set or passed through to the container like this:
 
-    RakeCompilerDock.sh "rake cross native gem OPENSSL_VERSION=#{ENV['OPENSSL_VERSION']}"
+```ruby
+RakeCompilerDock.sh "rake cross native gem OPENSSL_VERSION=#{ENV['OPENSSL_VERSION']}"
+```
 
 
 ## More information

data/Rakefile

@@ -1,11 +1,65 @@
+require 'erb'
+require "rake/clean"
 require "rake_compiler_dock"
-require "rake_compiler_dock/gem_helper"
+require_relative "build/gem_helper"
+require_relative "build/parallel_docker_build"
 
 RakeCompilerDock::GemHelper.install_tasks
 
-task :build do
-  sh "docker build -t larskanis/rake-compiler-dock-mri:#{RakeCompilerDock::IMAGE_VERSION} -f Dockerfile.mri ."
-  sh "docker build -t larskanis/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION} -f Dockerfile.jruby ."
+DOCKERHUB_USER = ENV['DOCKERHUB_USER'] || "larskanis"
+docker_build_cmd = Shellwords.split(ENV['RCD_DOCKER_BUILD'] || "docker build")
+
+platforms = [
+  ["x86-mingw32", "i686-w64-mingw32"],
+  ["x64-mingw32", "x86_64-w64-mingw32"],
+  ["x64-mingw-ucrt", "x86_64-w64-mingw32"],
+  ["x86-linux", "i686-redhat-linux"],
+  ["x86_64-linux", "x86_64-redhat-linux"],
+  ["x86_64-darwin", "x86_64-apple-darwin"],
+  ["arm64-darwin", "aarch64-apple-darwin"],
+  ["arm-linux", "arm-linux-gnueabihf"],
+  ["aarch64-linux", "aarch64-linux-gnu"],
+]
+
+namespace :build do
+
+  platforms.each do |platform, target|
+    sdf = "Dockerfile.mri.#{platform}"
+
+    desc "Build image for platform #{platform}"
+    task platform => sdf
+    task sdf do
+      sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/rake-compiler-dock-mri-#{platform}:#{RakeCompilerDock::IMAGE_VERSION}", "-f", "Dockerfile.mri.#{platform}", ".")
+    end
+
+    df = ERB.new(File.read("Dockerfile.mri.erb"), trim_mode: ">").result(binding)
+    File.write(sdf, df)
+    CLEAN.include(sdf)
+  end
+
+  desc "Build image for JRuby"
+  task :jruby => "Dockerfile.jruby"
+  task "Dockerfile.jruby" do
+    sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION}", "-f", "Dockerfile.jruby", ".")
+  end
+
+  RakeCompilerDock::ParallelDockerBuild.new(platforms.map{|pl, _| "Dockerfile.mri.#{pl}" } + ["Dockerfile.jruby"], workdir: "tmp/docker", docker_build_cmd: docker_build_cmd)
+
+  desc "Build images for all MRI platforms in parallel"
+  multitask :mri => platforms.map(&:first)
+
+  desc "Build images for all platforms in parallel"
+  multitask :all => platforms.map(&:first) + ["jruby"]
+end
+
+task :build => "build:all"
+
+namespace :prepare do
+  desc "Build cross compiler for x64-mingw-ucrt aka RubyInstaller-3.1+"
+  task "mingw64-ucrt" do
+    sh(*docker_build_cmd, "-t", "#{DOCKERHUB_USER}/mingw64-ucrt:20.04", ".",
+       chdir: "mingw64-ucrt")
+  end
 end
 
 desc "Run tests"
@@ -34,3 +88,16 @@ task :update_lists do
     EOT
   end
 end
+
+namespace :release do
+  desc "push all docker images"
+  task :images do
+    jimg = "#{DOCKERHUB_USER}/rake-compiler-dock-jruby:#{RakeCompilerDock::IMAGE_VERSION}"
+    sh "docker", "push", jimg
+
+    platforms.each do |platform, _|
+      img = "#{DOCKERHUB_USER}/rake-compiler-dock-mri-#{platform}:#{RakeCompilerDock::IMAGE_VERSION}"
+      sh "docker", "push", img
+    end
+  end
+end

data/{lib/rake_compiler_dock → build}/gem_helper.rb

@@ -1,18 +1,3 @@
-# This file is part of Libusb for Ruby.
-#
-# Libusb for Ruby is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# Libusb for Ruby is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with Libusb for Ruby.  If not, see <http://www.gnu.org/licenses/>.
-
 require "bundler/gem_helper"
 
 module RakeCompilerDock

data/build/parallel_docker_build.rb

@@ -0,0 +1,106 @@
+require "fileutils"
+require "rake"
+
+module RakeCompilerDock
+  # Run docker builds in parallel, but ensure that common docker layers are reused
+  class ParallelDockerBuild
+    include Rake::DSL
+
+    attr_reader :docker_build_cmd
+
+    def initialize(dockerfiles, workdir: "tmp/docker", inputdir: ".", task_prefix: "common-",
+                   docker_build_cmd: %w["docker", "build"])
+      @docker_build_cmd = docker_build_cmd
+      FileUtils.mkdir_p(workdir)
+
+      files = parse_dockerfiles(dockerfiles, inputdir)
+      # pp files
+
+      vcs = find_commons(files)
+      # pp vcs
+
+      define_common_tasks(vcs, workdir, task_prefix)
+    end
+
+    # Read given dockerfiles from inputdir and split into a list of commands.
+    #
+    # Returns:
+    #   {"File0"=>["      FROM a\n", "      RUN a\n", "      RUN d\n"],
+    #    "File1"=>["      FROM a\n",
+    #    ...
+    def parse_dockerfiles(dockerfiles, inputdir)
+      dockerfiles.map do |fn|
+        [fn, File.read(File.join(inputdir, fn))]
+      end.map do |fn, f|
+        # Split file contant in lines unless line ends with backslash
+        fc = f.each_line.with_object([]) do |line, lines|
+          if lines.last=~/\\\n\z/
+            lines.last << line
+          else
+            lines << line
+          end
+        end
+        [fn, fc]
+      end.to_h
+    end
+
+    # Build a tree of common parts of given files.
+    #
+    # Returns:
+    #   {["File0", "File1", "File2", "File3"]=>
+    #     [["  FROM a\n"],
+    #      {["File0", "File1"]=>
+    #        [["  RUN a\n", "  RUN d\n"], {["File1"]=>[["  RUN f\n"], {}]}],
+    #       ["File2", "File3"]=>[["  RUN b\n", "  RUN c\n", "  RUN d\n"], {}]}]}
+    def find_commons(files, vmask=nil, li=0)
+      vmask ||= files.keys
+      vcs = Hash.new { [] }
+      files.each do |fn, lines|
+        next unless vmask.include?(fn)
+        vcs[lines[li]] += [fn]
+      end
+
+      vcs.map do |line, vc|
+        next unless line
+        nvcs = find_commons(files, vc, li+1)
+        if nvcs.first && nvcs.first[0] == vc
+          # Append lines that are equal between file(s)
+          nl = [[line] + nvcs.first[1][0], nvcs.first[1][1]]
+        else
+          nl = [[line], nvcs]
+        end
+        [vc, nl]
+      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=[])
+      vcs.map do |files, (lines, nvcs)|
+        fn = "#{task_prefix}#{files.join}"
+        File.write(File.join(workdir, fn), (plines + lines).join)
+        task fn do
+          docker_build(fn, workdir)
+        end
+
+        nfn = define_common_tasks(nvcs, workdir, task_prefix, plines + lines)
+        nfn.each do |file|
+          task file => fn
+        end
+        files.each do |file|
+          task file => fn
+        end
+        fn
+      end
+    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, workdir)
+      sh(*docker_build_cmd, "-f", File.join(workdir, filename), ".")
+    end
+  end
+end

data/build/patches/{ruby-2.5.3 → ruby-2.5.9}/no_sendfile.patch

@@ -17,7 +17,7 @@ index 82c5940538..a8d3661ec8 100644
 @@ -10721,7 +10721,6 @@ nogvl_copy_stream_wait_write(struct copy_stream_struct *stp)
  }
 
- #if defined __linux__ && defined __NR_copy_file_range
+ #if defined HAVE_COPY_FILE_RANGE || (defined __linux__ && defined __NR_copy_file_range)
 -#  define USE_COPY_FILE_RANGE
  #endif
 

data/build/patches/ruby-3.1.0/no_sendfile.patch

@@ -0,0 +1,24 @@
+diff --git a/configure b/configure
+index ebe3d8c..a336b73 100755
+--- a/configure
++++ b/configure
+@@ -18943,7 +18943,6 @@ do :
+   ac_fn_c_check_func "$LINENO" "sendfile" "ac_cv_func_sendfile"
+ if test "x$ac_cv_func_sendfile" = xyes; then :
+   cat >>confdefs.h <<_ACEOF
+-#define HAVE_SENDFILE 1
+ _ACEOF
+
+ fi
+diff --git a/io.c b/io.c
+index 48592ac51a..2635ac8ec6 100644
+--- a/io.c
++++ b/io.c
+@@ -11111,6 +11111,7 @@ nogvl_copy_stream_wait_write(struct copy_stream_struct *stp)
+     return 0;
+ }
+
++#undef USE_COPY_FILE_RANGE
+ #ifdef USE_COPY_FILE_RANGE
+
+ static ssize_t

data/build/patches2/rake-compiler-1.1.6/0004-Enable-build-of-static-libruby.patch

@@ -0,0 +1,28 @@
+diff --git a/tasks/bin/cross-ruby.rake b/tasks/bin/cross-ruby.rake
+index 8317a2a..5a1b3ea 100644
+--- a/tasks/bin/cross-ruby.rake
++++ b/tasks/bin/cross-ruby.rake
+@@ -116,10 +116,22 @@ RUBY_CC_VERSIONS.split(":").each do |ruby_cc_version|
+         "--host=#{mingw_host}",
+         "--target=#{mingw_target}",
+         "--build=#{RUBY_BUILD}",
+-        '--enable-shared',
++        '--enable-install-static-library',
++        '--disable-jit-support',
+         '--disable-install-doc',
+         '--with-ext=',
+       ]
++      if mingw_host=~/darwin/
++        options += [
++          '--enable-static',
++          '--disable-shared',
++        ]
++      else
++        options += [
++          '--enable-static',
++          '--enable-shared',
++        ]
++      end
+ 
+       # Force Winsock2 for Ruby 1.8, 1.9 defaults to it
+       options << "--with-winsock2" if major == "1.8"

data/build/rcd-env.sh

@@ -0,0 +1,6 @@
+# set up a working RCD build environment
+export RAKE_EXTENSION_TASK_NO_NATIVE=true
+if ! test -e "$HOME"/.rake-compiler ; then
+  ln -s /usr/local/rake-compiler "$HOME"/.rake-compiler
+fi
+mkdir -p "$HOME"/.gem

data/build/runas

@@ -4,9 +4,4 @@ groupadd -o -g "$GID" "$GROUP"
 mkdir -p /tmp/home
 useradd -o -g "$GID" -u "$UID" -G rvm,sudo -p "" -b /tmp/home -m "$USER"
 
-HOME=$(bash <<< "echo ~$USER")
-ln -s /usr/local/rake-compiler "$HOME"/.rake-compiler
-
-sudo -u "$USER" --set-home \
-    BASH_ENV=/etc/rubybashrc \
-    -- "$@"
+/usr/bin/sudo -u "$USER" -H BASH_ENV=/etc/rubybashrc -- "$@"

data/build/sudoers

@@ -1 +1 @@
-Defaults        env_keep += "http_proxy https_proxy ftp_proxy RCD_HOST_RUBY_PLATFORM RCD_HOST_RUBY_VERSION RCD_IMAGE RUBY_CC_VERSION"
+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"

data/lib/rake_compiler_dock/docker_check.rb

@@ -8,6 +8,7 @@ module RakeCompilerDock
 
     attr_reader :io
     attr_reader :pwd
+    attr_reader :docker_command
     attr_accessor :machine_name
 
     def initialize(io, pwd, machine_name="rake-compiler-dock")
@@ -53,12 +54,17 @@ module RakeCompilerDock
       end
     end
 
+    COMMANDS = %w[docker podman]
     def docker_version
-      @docker_version_text, @docker_version_status = run("docker version")
+      COMMANDS.find do |command|
+        @docker_version_text, @docker_version_status = run("#{command} version")
+        @docker_command = command
+        @docker_version_status == 0
+      end
     end
 
     def ok?
-      @docker_version_status == 0 && @docker_version_text =~ /version/ && doma_pwd_ok?
+      @docker_version_status == 0 && @docker_version_text =~ /version/i && doma_pwd_ok?
     end
 
     def docker_client_avail?
@@ -216,16 +222,16 @@ module RakeCompilerDock
           help << yellow("Please download and install the docker-toolbox:")
           help << yellow("    https://www.docker.com/docker-toolbox")
         when /linux/
-          help << red("Docker is not available.")
+          help << red("Neither Docker nor Podman is available.")
           help << ""
-          help << yellow("Install on Ubuntu/Debian:")
+          help << yellow("Install Docker on Ubuntu/Debian:")
           help << "    sudo apt-get install docker.io"
           help << ""
-          help << yellow("Install on Fedora/Centos/RHEL")
+          help << yellow("Install Docker on Fedora/Centos/RHEL")
           help << "    sudo yum install docker"
           help << "    sudo systemctl start docker"
           help << ""
-          help << yellow("Install on SuSE")
+          help << yellow("Install Docker on SuSE")
           help << "    sudo zypper install docker"
           help << "    sudo systemctl start docker"
         when /darwin/