tiny_tds 2.1.2 → 2.1.7

data/Rakefile

@@ -6,19 +6,33 @@ require 'rake/extensiontask'
 require_relative './ext/tiny_tds/extconsts'
 
 SPEC = Gem::Specification.load(File.expand_path('../tiny_tds.gemspec', __FILE__))
+
+ruby_cc_ucrt_versions = "3.3.0:3.2.0:3.1.0".freeze
+ruby_cc_mingw32_versions = "3.0.0:2.7.0:2.6.0:2.5.0:2.4.0".freeze
+
 GEM_PLATFORM_HOSTS = {
-  'x86-mingw32' => 'i686-w64-mingw32',
-  'x64-mingw32' => 'x86_64-w64-mingw32'
+  'x86-mingw32' => {
+    host: 'i686-w64-mingw32',
+    ruby_versions: ruby_cc_mingw32_versions
+  },
+  'x64-mingw32' => {
+    host: 'x86_64-w64-mingw32',
+    ruby_versions: ruby_cc_mingw32_versions
+  },
+  'x64-mingw-ucrt' => {
+    host: 'x86_64-w64-mingw32',
+    ruby_versions: ruby_cc_ucrt_versions
+  },
 }
 
 # Add our project specific files to clean for a rebuild
 CLEAN.include FileList["{ext,lib}/**/*.{so,#{RbConfig::CONFIG['DLEXT']},o}"],
-  FileList["exe/*"]
+              FileList["exe/*"]
 
 # Clobber all our temp files and ports files including .install files
 # and archives
 CLOBBER.include FileList["tmp/**/*"],
-  FileList["ports/**/*"].exclude(%r{^ports/archives})
+                FileList["ports/**/*"].exclude(%r{^ports/archives})
 
 Dir['tasks/*.rake'].sort.each { |f| load f }
 
@@ -32,15 +46,11 @@ Rake::ExtensionTask.new('tiny_tds', SPEC) do |ext|
     # The fat binary gem doesn't depend on the freetds package, since it bundles the library.
     spec.metadata.delete('msys2_mingw_dependencies')
 
-    platform_host_map = GEM_PLATFORM_HOSTS
-    gemplat = spec.platform.to_s
-    host = platform_host_map[gemplat]
-
     # We don't need the sources in a fat binary gem
     spec.files = spec.files.reject { |f| f =~ %r{^ports\/archives/} }
 
     # Make sure to include the ports binaries and libraries
-    spec.files += FileList["ports/#{host}/**/**/{bin,lib}/*"].exclude do |f|
+    spec.files += FileList["ports/#{spec.platform.to_s}/**/**/{bin,lib}/*"].exclude do |f|
       File.directory? f
     end
 
@@ -50,4 +60,3 @@ end
 
 task build: [:clean, :compile]
 task default: [:build, :test]
-

data/VERSION

@@ -1 +1 @@
-2.1.2
+2.1.7

data/docker-compose.yml

@@ -0,0 +1,34 @@
+version: '3'
+
+networks:
+  main-network:
+
+services:
+  mssql:
+    image: metaskills/mssql-server-linux-tinytds:2017-GA
+    container_name: sqlserver
+    environment:
+      ACCEPT_EULA: Y
+      SA_PASSWORD: super01S3cUr3
+    ports:
+      - "1433:1433"
+    network_mode: "host"
+
+  toxiproxy:
+    image: shopify/toxiproxy
+    container_name: toxiproxy
+    command: '/toxiproxy -host=127.0.0.1'
+    network_mode: "host"
+
+  cimgruby:
+    image: "cimg/ruby:${RUBY_VERSION:-2.7}"
+    container_name: cimg_ruby
+    environment:
+      TESTOPTS: '-v'
+      TINYTDS_UNIT_HOST: '127.0.0.1'
+      SA_PASSWORD: super01S3cUr3
+      TOXIPROXY_HOST: '127.0.0.1'
+    command: tail -F anything
+    volumes:
+      - .:/home/circleci/project
+    network_mode: "host"

data/ext/tiny_tds/client.c

@@ -24,25 +24,25 @@ VALUE opt_escape_regex, opt_escape_dblquote;
 
 // Lib Backend (Helpers)
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, const char *error, const char *source, int severity, int dberr, int oserr) {
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error) {
   VALUE e;
   GET_CLIENT_USERDATA(dbproc);
-  if (cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
+  if (error.cancel && !dbdead(dbproc) && userdata && !userdata->closed) {
     userdata->dbsqlok_sent = 1;
     dbsqlok(dbproc);
     userdata->dbcancel_sent = 1;
     dbcancel(dbproc);
   }
-  e = rb_exc_new2(cTinyTdsError, error);
-  rb_funcall(e, intern_source_eql, 1, rb_str_new2(source));
-  if (severity)
-    rb_funcall(e, intern_severity_eql, 1, INT2FIX(severity));
-  if (dberr)
-    rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(dberr));
-  if (oserr)
-    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(oserr));
-
-  if (severity <= 10 && is_message) {
+  e = rb_exc_new2(cTinyTdsError, error.error);
+  rb_funcall(e, intern_source_eql, 1, rb_str_new2(error.source));
+  if (error.severity)
+    rb_funcall(e, intern_severity_eql, 1, INT2FIX(error.severity));
+  if (error.dberr)
+    rb_funcall(e, intern_db_error_number_eql, 1, INT2FIX(error.dberr));
+  if (error.oserr)
+    rb_funcall(e, intern_os_error_number_eql, 1, INT2FIX(error.oserr));
+
+  if (error.severity <= 10 && error.is_message) {
     VALUE message_handler = userdata && userdata->message_handler ? userdata->message_handler : Qnil;
     if (message_handler && message_handler != Qnil && rb_respond_to(message_handler, intern_call) != 0) {
       rb_funcall(message_handler, intern_call, 1, e);
@@ -57,6 +57,16 @@ VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, cons
 
 
 // Lib Backend (Memory Management & Handlers)
+static void push_userdata_error(tinytds_client_userdata *userdata, tinytds_errordata error) {
+  // reallocate memory for the array as needed
+  if (userdata->nonblocking_errors_size == userdata->nonblocking_errors_length) {
+    userdata->nonblocking_errors_size *= 2;
+    userdata->nonblocking_errors = realloc(userdata->nonblocking_errors, userdata->nonblocking_errors_size * sizeof(tinytds_errordata));
+  }
+
+  userdata->nonblocking_errors[userdata->nonblocking_errors_length] = error;
+  userdata->nonblocking_errors_length++;
+}
 
 int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr) {
   static const char *source = "error";
@@ -86,6 +96,13 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       but we don't ever want to automatically retry. Instead have the app
       decide what to do.
       */
+      if (userdata && userdata->timing_out) {
+        return INT_CANCEL;
+      }
+      // userdata will not be set if hitting timeout during login so check for it first
+      if (userdata) {
+        userdata->timing_out = 1;
+      }
       return_value = INT_TIMEOUT;
       cancel = 1;
       break;
@@ -99,6 +116,16 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       break;
   }
 
+  tinytds_errordata error_data = {
+    .is_message = 0,
+    .cancel = cancel,
+    .severity = severity,
+    .dberr = dberr,
+    .oserr = oserr
+  };
+  strncpy(error_data.error, dberrstr, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
   /*
   When in non-blocking mode we need to store the exception data to throw it
   once the blocking call returns, otherwise we will segfault ruby since part
@@ -110,27 +137,9 @@ int tinytds_err_handler(DBPROCESS *dbproc, int severity, int dberr, int oserr, c
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
-
-    /*
-    If we've already captured an error message, don't overwrite it. This is
-    here because FreeTDS sends a generic "General SQL Server error" message
-    that will overwrite the real message. This is not normally a problem
-    because a ruby exception is normally thrown and we bail before the
-    generic message can be sent.
-    */
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = 0;
-      userdata->nonblocking_error.cancel = cancel;
-      strncpy(userdata->nonblocking_error.error, dberrstr, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = dberr;
-      userdata->nonblocking_error.oserr = oserr;
-      userdata->nonblocking_error.is_set = 1;
-    }
-
+    push_userdata_error(userdata, error_data);
   } else {
-    rb_tinytds_raise_error(dbproc, 0, cancel, dberrstr, source, severity, dberr, oserr);
+    rb_tinytds_raise_error(dbproc, error_data);
   }
 
   return return_value;
@@ -142,36 +151,72 @@ int tinytds_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate, int severi
 
   int is_message_an_error = severity > 10 ? 1 : 0;
 
+  tinytds_errordata error_data = {
+    .is_message = !is_message_an_error,
+    .cancel = is_message_an_error,
+    .severity = severity,
+    .dberr = msgno,
+    .oserr = msgstate
+  };
+  strncpy(error_data.error, msgtext, ERROR_MSG_SIZE);
+  strncpy(error_data.source, source, ERROR_MSG_SIZE);
+
   // See tinytds_err_handler() for info about why we do this
   if (userdata && userdata->nonblocking) {
-    if (!userdata->nonblocking_error.is_set) {
-      userdata->nonblocking_error.is_message = !is_message_an_error;
-      userdata->nonblocking_error.cancel = is_message_an_error;
-      strncpy(userdata->nonblocking_error.error, msgtext, ERROR_MSG_SIZE);
-      strncpy(userdata->nonblocking_error.source, source, ERROR_MSG_SIZE);
-      userdata->nonblocking_error.severity = severity;
-      userdata->nonblocking_error.dberr = msgno;
-      userdata->nonblocking_error.oserr = msgstate;
-      userdata->nonblocking_error.is_set = 1;
-    }
+    /*
+    In the case of non-blocking command batch execution we can receive multiple messages
+    (including errors). We keep track of those here so they can be processed once the
+    non-blocking call returns.
+    */
+    push_userdata_error(userdata, error_data);
 
     if (is_message_an_error && !dbdead(dbproc) && !userdata->closed) {
       dbcancel(dbproc);
       userdata->dbcancel_sent = 1;
     }
   } else {
-    rb_tinytds_raise_error(dbproc, !is_message_an_error, is_message_an_error, msgtext, source, severity, msgno, msgstate);
+    rb_tinytds_raise_error(dbproc, error_data);
   }
   return 0;
 }
 
+/*
+Used by dbsetinterrupt -
+This gets called periodically while waiting on a read from the server
+Right now, we only care about cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+In these cases we decide that we actually want to handle the interrupt
+*/
+static int check_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  return userdata->timing_out;
+}
+
+/*
+Used by dbsetinterrupt -
+This gets called if check_interrupt returns TRUE.
+Right now, this is only used in cases where a read from the server is
+taking longer than the specified timeout and dbcancel is not working.
+Return INT_CANCEL to abort the current command batch.
+*/
+static int handle_interrupt(void *ptr) {
+  GET_CLIENT_USERDATA((DBPROCESS *)ptr);
+  if (userdata->timing_out) {
+    return INT_CANCEL;
+  }
+  return INT_CONTINUE;
+}
+
 static void rb_tinytds_client_reset_userdata(tinytds_client_userdata *userdata) {
   userdata->timing_out = 0;
   userdata->dbsql_sent = 0;
   userdata->dbsqlok_sent = 0;
   userdata->dbcancel_sent = 0;
   userdata->nonblocking = 0;
-  userdata->nonblocking_error.is_set = 0;
+  // the following is mainly done for consistency since the values are reset accordingly in nogvl_setup/cleanup.
+  // the nonblocking_errors array does not need to be freed here. That is done as part of nogvl_cleanup.
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static void rb_tinytds_client_mark(void *ptr) {
@@ -187,6 +232,7 @@ static void rb_tinytds_client_free(void *ptr) {
     dbloginfree(cwrap->login);
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
+    cwrap->client = NULL;
     cwrap->closed = 1;
     cwrap->userdata->closed = 1;
   }
@@ -218,6 +264,7 @@ static VALUE rb_tinytds_close(VALUE self) {
   GET_CLIENT_WRAPPER(self);
   if (cwrap->client && !cwrap->closed) {
     dbclose(cwrap->client);
+    cwrap->client = NULL;
     cwrap->closed = 1;
     cwrap->userdata->closed = 1;
   }
@@ -381,6 +428,7 @@ static VALUE rb_tinytds_connect(VALUE self, VALUE opts) {
       }
     }
     dbsetuserdata(cwrap->client, (BYTE*)cwrap->userdata);
+    dbsetinterrupt(cwrap->client, check_interrupt, handle_interrupt);
     cwrap->userdata->closed = 0;
     if (!NIL_P(database) && (azure != Qtrue)) {
       dbuse(cwrap->client, StringValueCStr(database));

data/ext/tiny_tds/client.h

@@ -5,9 +5,9 @@
 void init_tinytds_client();
 
 #define ERROR_MSG_SIZE 1024
+#define ERRORS_STACK_INIT_SIZE 2
 
 typedef struct {
-  short int is_set;
   int is_message;
   int cancel;
   char error[ERROR_MSG_SIZE];
@@ -25,7 +25,9 @@ typedef struct {
   RETCODE dbsqlok_retcode;
   short int dbcancel_sent;
   short int nonblocking;
-  tinytds_errordata nonblocking_error;
+  short int nonblocking_errors_length;
+  short int nonblocking_errors_size;
+  tinytds_errordata *nonblocking_errors;
   VALUE message_handler;
 } tinytds_client_userdata;
 
@@ -40,7 +42,7 @@ typedef struct {
   rb_encoding *encoding;
 } tinytds_client_wrapper;
 
-VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, int is_message, int cancel, const char *error, const char *source, int severity, int dberr, int oserr);
+VALUE rb_tinytds_raise_error(DBPROCESS *dbproc, tinytds_errordata error);
 
 // Lib Macros
 

data/ext/tiny_tds/extconf.rb

@@ -21,36 +21,59 @@ end
 do_help if arg_config('--help')
 
 # Make sure to check the ports path for the configured host
-host = RbConfig::CONFIG['host']
-project_dir = File.join(['..']*4)
-freetds_ports_dir = File.join(project_dir, 'ports', host, 'freetds', FREETDS_VERSION)
+architecture = RbConfig::CONFIG['arch']
+architecture = "x86-mingw32" if architecture == "i386-mingw32"
+
+project_dir = File.expand_path("../../..", __FILE__)
+freetds_ports_dir = File.join(project_dir, 'ports', architecture, 'freetds', FREETDS_VERSION)
 freetds_ports_dir = File.expand_path(freetds_ports_dir)
 
 # Add all the special path searching from the original tiny_tds build
-# order is important here! First in, last searched.
+# order is important here! First in, first searched.
 DIRS = %w(
-  /usr/local
   /opt/local
+  /usr/local
 )
 
-# Grab freetds environment variable for use by people on services like
-# Heroku who they can't easily use bundler config to set directories
-DIRS.push(ENV['FREETDS_DIR']) if ENV.has_key?('FREETDS_DIR')
+if RbConfig::CONFIG['host_os'] =~ /darwin/i
+  # Ruby below 2.7 seems to label the host CPU on Apple Silicon as aarch64
+  # 2.7 and above print is as ARM64
+  target_host_cpu = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7') ? 'aarch64' : 'arm64'
+
+  if RbConfig::CONFIG['host_cpu'] == target_host_cpu
+    # Homebrew on Apple Silicon installs into /opt/hombrew
+    # https://docs.brew.sh/Installation
+    # On Intel Macs, it is /usr/local, so no changes necessary to DIRS
+    DIRS.unshift("/opt/homebrew")
+  end
+end
+
+if ENV["RI_DEVKIT"] && ENV["MINGW_PREFIX"] # RubyInstaller Support
+  DIRS.unshift(File.join(ENV["RI_DEVKIT"], ENV["MINGW_PREFIX"]))
+end
 
 # Add the ports directory if it exists for local developer builds
-DIRS.push(freetds_ports_dir) if File.directory?(freetds_ports_dir)
+DIRS.unshift(freetds_ports_dir) if File.directory?(freetds_ports_dir)
+
+# Grab freetds environment variable for use by people on services like
+# Heroku who they can't easily use bundler config to set directories
+DIRS.unshift(ENV['FREETDS_DIR']) if ENV.has_key?('FREETDS_DIR')
 
 # Add the search paths for freetds configured above
-DIRS.each do |path|
-  idir = "#{path}/include"
+ldirs = DIRS.flat_map do |path|
   ldir = "#{path}/lib"
+  [ldir, "#{ldir}/freetds"]
+end
 
-  dir_config('freetds',
-    [idir, "#{idir}/freetds"],
-    [ldir, "#{ldir}/freetds"]
-  )
+idirs = DIRS.flat_map do |path|
+  idir = "#{path}/include"
+  [idir, "#{idir}/freetds"]
 end
 
+puts "looking for freetds headers in the following directories:\n#{idirs.map{|a| " - #{a}\n"}.join}"
+puts "looking for freetds library in the following directories:\n#{ldirs.map{|a| " - #{a}\n"}.join}"
+dir_config('freetds', idirs, ldirs)
+
 have_dependencies = [
   find_header('sybfront.h'),
   find_header('sybdb.h'),

data/ext/tiny_tds/extconsts.rb

@@ -2,10 +2,10 @@
 ICONV_VERSION = ENV['TINYTDS_ICONV_VERSION'] || "1.15"
 ICONV_SOURCE_URI = "http://ftp.gnu.org/pub/gnu/libiconv/libiconv-#{ICONV_VERSION}.tar.gz"
 
-OPENSSL_VERSION = ENV['TINYTDS_OPENSSL_VERSION'] || '1.1.0e'
+OPENSSL_VERSION = ENV['TINYTDS_OPENSSL_VERSION'] || '1.1.1s'
 OPENSSL_SOURCE_URI = "https://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
 
-FREETDS_VERSION = ENV['TINYTDS_FREETDS_VERSION'] || "1.00.27"
+FREETDS_VERSION = ENV['TINYTDS_FREETDS_VERSION'] || "1.1.24"
 FREETDS_VERSION_INFO = Hash.new { |h,k|
   h[k] = {files: "http://www.freetds.org/files/stable/freetds-#{k}.tar.bz2"}
 }

data/ext/tiny_tds/result.c

@@ -86,26 +86,40 @@ static void dbcancel_ubf(DBPROCESS *client) {
 static void nogvl_setup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 1;
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors = malloc(ERRORS_STACK_INIT_SIZE * sizeof(tinytds_errordata));
+  userdata->nonblocking_errors_size = ERRORS_STACK_INIT_SIZE;
 }
 
 static void nogvl_cleanup(DBPROCESS *client) {
   GET_CLIENT_USERDATA(client);
   userdata->nonblocking = 0;
+  userdata->timing_out = 0;
   /*
   Now that the blocking operation is done, we can finally throw any
   exceptions based on errors from SQL Server.
   */
-  if (userdata->nonblocking_error.is_set) {
-    userdata->nonblocking_error.is_set = 0;
-    rb_tinytds_raise_error(client,
-      userdata->nonblocking_error.is_message,
-      userdata->nonblocking_error.cancel,
-      userdata->nonblocking_error.error,
-      userdata->nonblocking_error.source,
-      userdata->nonblocking_error.severity,
-      userdata->nonblocking_error.dberr,
-      userdata->nonblocking_error.oserr);
+  short int i;
+  for (i = 0; i < userdata->nonblocking_errors_length; i++) {
+    tinytds_errordata error = userdata->nonblocking_errors[i];
+
+    // lookahead to drain any info messages ahead of raising error
+    if (!error.is_message) {
+      short int j;
+      for (j = i; j < userdata->nonblocking_errors_length; j++) {
+        tinytds_errordata msg_error = userdata->nonblocking_errors[j];
+        if (msg_error.is_message) {
+          rb_tinytds_raise_error(client, msg_error);
+        }
+      }
+    }
+
+    rb_tinytds_raise_error(client, error);
   }
+
+  free(userdata->nonblocking_errors);
+  userdata->nonblocking_errors_length = 0;
+  userdata->nonblocking_errors_size = 0;
 }
 
 static RETCODE nogvl_dbsqlok(DBPROCESS *client) {
@@ -570,6 +584,7 @@ void init_tinytds_result() {
   cDate = rb_const_get(rb_cObject, rb_intern("Date"));
   /* Define TinyTds::Result */
   cTinyTdsResult = rb_define_class_under(mTinyTds, "Result", rb_cObject);
+  rb_undef_alloc_func(cTinyTdsResult);
   /* Define TinyTds::Result Public Methods */
   rb_define_method(cTinyTdsResult, "fields", rb_tinytds_result_fields, 0);
   rb_define_method(cTinyTdsResult, "each", rb_tinytds_result_each, -1);

data/lib/tiny_tds/gem.rb

@@ -20,12 +20,7 @@ module TinyTds
       end
 
       def ports_host
-        h = RbConfig::CONFIG['host']
-
-        # Our fat binary builds with a i686-w64-mingw32 toolchain
-        # but ruby for windows x32-mingw32 reports i686-pc-mingw32
-        # so correct the host here
-        h.gsub('i686-pc-mingw32', 'i686-w64-mingw32')
+        RbConfig::CONFIG["arch"]
       end
     end
   end

data/setup_cimgruby_dev.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+set -x
+set -e
+
+# this should mirror the steps outlined in the circleci yml
+echo "Installing mssql-tools..."
+sleep 5
+sudo -E ./test/bin/install-mssqltools.sh
+
+echo "Configurating tinytds test database..."
+sleep 5
+./test/bin/setup_tinytds_db.sh
+
+echo "Building openssl library..."
+sleep 5
+sudo -E ./test/bin/install-openssl.sh
+
+echo "Building freetds library..."
+sleep 5
+sudo -E ./test/bin/install-freetds.sh
+
+echo "Installing gems..."
+sleep 5
+bundle install

data/start_dev.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -x
+set -e
+
+# set volume read/write permissions to work both outside and inside container
+sudo ./test/bin/setup_volume_permissions.sh
+
+docker-compose up -d
+echo "Waiting for containers to start..."
+sleep 10
+
+# setup circleci ruby container for development
+docker exec cimg_ruby bash -c './setup_cimgruby_dev.sh'
+
+# enter container
+set +x
+echo "cimg/ruby container is ready for tiny_tds development.........."
+echo "To enter container run: docker exec -it cimg_ruby /bin/bash"
+echo "To build solution run: docker exec cimg_ruby bash -c 'bundle exec rake build'"
+echo "To test solution run: docker exec cimg_ruby bash -c 'bundle exec rake test'"

data/tasks/native_gem.rake

@@ -1,14 +1,23 @@
 # encoding: UTF-8
 
-desc 'Build the windows binary gems per rake-compiler-dock'
-task 'gem:windows' => ['ports:cross'] do
+desc 'Build the native binary gems using rake-compiler-dock'
+task 'gem:native' => ['ports:cross'] do
   require 'rake_compiler_dock'
 
   # make sure to install our bundle
-  build = ['bundle']
+  sh "bundle package --all" # Avoid repeated downloads of gems by using gem files from the host.
 
-  # and finally build the native gem
-  build << 'rake cross native gem RUBY_CC_VERSION=2.5.0:2.4.0:2.3.0:2.2.2:2.1.6:2.0.0 CFLAGS="-Wall" MAKE="make -j`nproc`"'
+  GEM_PLATFORM_HOSTS.each do |plat, meta|
+    RakeCompilerDock.sh "bundle --local && RUBY_CC_VERSION=#{meta[:ruby_versions]} rake native:#{plat} gem", platform: plat
+  end
+end
+
+# assumes you are in a container provided by Rake compiler
+# if not, use the task above
+task 'gem:for_platform', [:gem_platform] do |_task, args|
+  args.with_defaults(gem_platform: RbConfig::CONFIG["arch"])
 
-  RakeCompilerDock.sh build.join(' && ')
+  sh "bundle install"
+  Rake::Task["ports:compile"].invoke(GEM_PLATFORM_HOSTS[args.gem_platform][:host], args.gem_platform)
+  sh "RUBY_CC_VERSION=#{GEM_PLATFORM_HOSTS[args.gem_platform][:ruby_versions]} rake native:#{args.gem_platform} gem"
 end

data/tasks/ports/libiconv.rb

@@ -8,25 +8,8 @@ module Ports
       set_patches
     end
 
-    def cook
-      chdir_for_build do
-        super
-      end
-      self
-    end
-
     private
 
-    # When using rake-compiler-dock on Windows, the underlying Virtualbox shared
-    # folders don't support symlinks, but libiconv expects it for a build on
-    # Linux. We work around this limitation by using the temp dir for cooking.
-    def chdir_for_build
-      build_dir = ENV['RCD_HOST_RUBY_PLATFORM'].to_s =~ /mingw|mswin|cygwin/ ? '/tmp' : '.'
-      Dir.chdir(build_dir) do
-        yield
-      end
-    end
-
     def configure_defaults
       [
         "--host=#{@host}",

data/tasks/ports/openssl.rb

@@ -27,27 +27,11 @@ module Ports
 
     private
 
-    def execute(action, command, options={})
-      # OpenSSL Requires Perl >= 5.10, while the Ruby devkit uses MSYS1 with Perl 5.8.8.
-      # To overcome this, prepend Git's usr/bin to the PATH.
-      # It has MSYS2 with a recent version of perl.
-      prev_path = ENV['PATH']
-      if host =~ /mingw/ && IO.popen(["perl", "-e", "print($])"], &:read).to_f < 5.010
-        git_perl = 'C:/Program Files/Git/usr/bin'
-        if File.directory?(git_perl)
-          ENV['PATH'] = "#{git_perl}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
-          ENV['PERL'] = 'perl'
-        end
-      end
-
-      super
-      ENV['PATH'] = prev_path
-    end
-
     def configure_defaults
       opts = [
         'shared',
-        target_arch
+        target_arch,
+        "--openssldir=#{path}",
       ]
 
       if cross_build?