bootsnap 1.4.3-java → 1.4.8-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1da2c9355b194f496d516037840a1853128f3e3b
-  data.tar.gz: 310e93db85d4dc71647ab155e5a25b0af265533f
+  metadata.gz: 9f22bac3ef9ae0e60d14aa58792ac2d824b9e6af
+  data.tar.gz: 689f27baac58dab8c6fc3dfc9225225ada89545f
 SHA512:
-  metadata.gz: 37ae91b0e6b0cc9fa79f6e3745888dde06b6d3d69f06fa9a6c41b551d9b5a914438475c2999da8e9812fdb665d580467d3659e86e5c3fe9570795cb2095df418
-  data.tar.gz: f7803683394dda64d2c68c9c3fc0d8868183f35fe0b56d8867c02bdbb597e86d843bd5c35de04730dc3f866afc77b9b5de376783582ac2515625bff08429cd3b
+  metadata.gz: 226139367737c0832c66b3a36ca27cf400ab3add25130cdcfe9f572de35c3d17d03861e2715673d4cb0cb08bef9ccfa06da33a638a64f2e203c8cf281f3da209
+  data.tar.gz: c70b64e4273a4321e127ee4a7559412205821d0c97931d37c20fd0231b81312064ef9b238cc4749d15e41724bbf3cee6694b3e79b43adaf3790f153474a828f7

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+# 1.4.8
+
+* [Prevent FallbackScan from polluting exception cause](https://github.com/Shopify/bootsnap/pull/314)
+
+# 1.4.7
+
+* Various performance enhancements
+* Fix race condition in heavy concurrent load scenarios that would cause bootsnap to raise
+
+# 1.4.6
+
+* Fix bug that was erroneously considering that files containing `.` in the names were being
+  required if a different file with the same name was already being required
+
+  Example:
+  
+      require 'foo'
+      require 'foo.en'
+
+  Before bootsnap was considering `foo.en` to be the same file as `foo`
+
+* Use glibc as part of the ruby_platform cache key
+
+# 1.4.5
+
+* MRI 2.7 support
+* Fixed concurrency bugs
+
+# 1.4.4
+
+* Disable ISeq cache in `bootsnap/setup` by default in Ruby 2.5
+
 # 1.4.3
 
 * Fix some cache permissions and umask issues after switch to mkstemp

data/README.md

@@ -214,7 +214,7 @@ Bootsnap writes a cache file containing a 64 byte header followed by the cache c
 is a cache key including several fields:
 
 * `version`, hardcoded in bootsnap. Essentially a schema version;
-* `os_version`, A hash of the current kernel version (on macOS, BSD) or glibc version (on Linux);
+* `ruby_platform`, A hash of `RUBY_PLATFORM` (e.g. x86_64-linux-gnu) variable and glibc version (on Linux) or OS version (`uname -v` on BSD, macOS)
 * `compile_option`, which changes with `RubyVM::InstructionSequence.compile_option` does;
 * `ruby_revision`, the version of Ruby this was compiled with;
 * `size`, the size of the source file;

data/ext/bootsnap/bootsnap.c

@@ -21,6 +21,9 @@
 #ifndef _WIN32
 #include <sys/utsname.h>
 #endif
+#ifdef __GLIBC__
+#include <gnu/libc-version.h>
+#endif
 
 /* 1000 is an arbitrary limit; FNV64 plus some slashes brings the cap down to
  * 981 for the cache dir */
@@ -29,6 +32,8 @@
 
 #define KEY_SIZE 64
 
+#define MAX_CREATE_TEMPFILE_ATTEMPT 3
+
 /*
  * An instance of this key is written as the first 64 bytes of each cache file.
  * The mtime and size members track whether the file contents have changed, and
@@ -90,12 +95,13 @@ static VALUE bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handl
 
 /* Helpers */
 static uint64_t fnv1a_64(const char *str);
-static void bs_cache_path(const char * cachedir, const char * path, char ** cache_path);
+static void bs_cache_path(const char * cachedir, const char * path, char (* cache_path)[MAX_CACHEPATH_SIZE]);
 static int bs_read_key(int fd, struct bs_cache_key * key);
 static int cache_key_equal(struct bs_cache_key * k1, struct bs_cache_key * k2);
 static VALUE bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler);
-static int open_current_file(char * path, struct bs_cache_key * key, char ** errno_provenance);
-static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, char ** errno_provenance);
+static int open_current_file(char * path, struct bs_cache_key * key, const char ** errno_provenance);
+static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, const char ** errno_provenance);
+static uint32_t get_ruby_revision(void);
 static uint32_t get_ruby_platform(void);
 
 /*
@@ -136,7 +142,7 @@ Init_bootsnap(void)
   rb_mBootsnap_CompileCache_Native = rb_define_module_under(rb_mBootsnap_CompileCache, "Native");
   rb_eBootsnap_CompileCache_Uncompilable = rb_define_class_under(rb_mBootsnap_CompileCache, "Uncompilable", rb_eStandardError);
 
-  current_ruby_revision = FIX2INT(rb_const_get(rb_cObject, rb_intern("RUBY_REVISION")));
+  current_ruby_revision = get_ruby_revision();
   current_ruby_platform = get_ruby_platform();
 
   uncompilable = rb_intern("__bootsnap_uncompilable__");
@@ -196,6 +202,26 @@ fnv1a_64(const char *str)
   return fnv1a_64_iter(h, str);
 }
 
+/*
+ * Ruby's revision may be Integer or String. CRuby 2.7 or later uses
+ * Git commit ID as revision. It's String.
+ */
+static uint32_t
+get_ruby_revision(void)
+{
+  VALUE ruby_revision;
+
+  ruby_revision = rb_const_get(rb_cObject, rb_intern("RUBY_REVISION"));
+  if (RB_TYPE_P(ruby_revision, RUBY_T_FIXNUM)) {
+    return FIX2INT(ruby_revision);
+  } else {
+    uint64_t hash;
+
+    hash = fnv1a_64(StringValueCStr(ruby_revision));
+    return (uint32_t)(hash >> 32);
+  }
+}
+
 /*
  * When ruby's version doesn't change, but it's recompiled on a different OS
  * (or OS version), we need to invalidate the cache.
@@ -215,6 +241,9 @@ get_ruby_platform(void)
 
 #ifdef _WIN32
   return (uint32_t)(hash >> 32) ^ (uint32_t)GetVersion();
+#elif defined(__GLIBC__)
+  hash = fnv1a_64_iter(hash, gnu_get_libc_version());
+  return (uint32_t)(hash >> 32);
 #else
   struct utsname utsname;
 
@@ -235,7 +264,7 @@ get_ruby_platform(void)
  * The path will look something like: <cachedir>/12/34567890abcdef
  */
 static void
-bs_cache_path(const char * cachedir, const char * path, char ** cache_path)
+bs_cache_path(const char * cachedir, const char * path, char (* cache_path)[MAX_CACHEPATH_SIZE])
 {
   uint64_t hash = fnv1a_64(path);
 
@@ -287,10 +316,8 @@ bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler)
   char * path     = RSTRING_PTR(path_v);
   char cache_path[MAX_CACHEPATH_SIZE];
 
-  { /* generate cache path to cache_path */
-    char * tmp = (char *)&cache_path;
-    bs_cache_path(cachedir, path, &tmp);
-  }
+  /* generate cache path to cache_path */
+  bs_cache_path(cachedir, path, &cache_path);
 
   return bs_fetch(path, path_v, cache_path, handler);
 }
@@ -300,14 +327,14 @@ bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler)
  * was loaded.
  */
 static int
-open_current_file(char * path, struct bs_cache_key * key, char ** errno_provenance)
+open_current_file(char * path, struct bs_cache_key * key, const char ** errno_provenance)
 {
   struct stat statbuf;
   int fd;
 
   fd = open(path, O_RDONLY);
   if (fd < 0) {
-    *errno_provenance = (char *)"bs_fetch:open_current_file:open";
+    *errno_provenance = "bs_fetch:open_current_file:open";
     return fd;
   }
   #ifdef _WIN32
@@ -315,7 +342,7 @@ open_current_file(char * path, struct bs_cache_key * key, char ** errno_provenan
   #endif
 
   if (fstat(fd, &statbuf) < 0) {
-    *errno_provenance = (char *)"bs_fetch:open_current_file:fstat";
+    *errno_provenance = "bs_fetch:open_current_file:fstat";
     close(fd);
     return -1;
   }
@@ -361,13 +388,13 @@ bs_read_key(int fd, struct bs_cache_key * key)
  *   - ERROR_WITH_ERRNO (-1, errno is set)
  */
 static int
-open_cache_file(const char * path, struct bs_cache_key * key, char ** errno_provenance)
+open_cache_file(const char * path, struct bs_cache_key * key, const char ** errno_provenance)
 {
   int fd, res;
 
   fd = open(path, O_RDONLY);
   if (fd < 0) {
-    *errno_provenance = (char *)"bs_fetch:open_cache_file:open";
+    *errno_provenance = "bs_fetch:open_cache_file:open";
     if (errno == ENOENT) return CACHE_MISSING_OR_INVALID;
     return ERROR_WITH_ERRNO;
   }
@@ -377,7 +404,7 @@ open_cache_file(const char * path, struct bs_cache_key * key, char ** errno_prov
 
   res = bs_read_key(fd, key);
   if (res < 0) {
-    *errno_provenance = (char *)"bs_fetch:open_cache_file:read";
+    *errno_provenance = "bs_fetch:open_cache_file:read";
     close(fd);
     return res;
   }
@@ -401,7 +428,7 @@ open_cache_file(const char * path, struct bs_cache_key * key, char ** errno_prov
  * or exception, will be the final data returnable to the user.
  */
 static int
-fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, char ** errno_provenance)
+fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, const char ** errno_provenance)
 {
   char * data = NULL;
   ssize_t nread;
@@ -410,7 +437,7 @@ fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data,
   VALUE storage_data;
 
   if (data_size > 100000000000) {
-    *errno_provenance = (char *)"bs_fetch:fetch_cached_data:datasize";
+    *errno_provenance = "bs_fetch:fetch_cached_data:datasize";
     errno = EINVAL; /* because wtf? */
     ret = -1;
     goto done;
@@ -418,7 +445,7 @@ fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data,
   data = ALLOC_N(char, data_size);
   nread = read(fd, data, data_size);
   if (nread < 0) {
-    *errno_provenance = (char *)"bs_fetch:fetch_cached_data:read";
+    *errno_provenance = "bs_fetch:fetch_cached_data:read";
     ret = -1;
     goto done;
   }
@@ -470,29 +497,36 @@ mkpath(char * file_path, mode_t mode)
  * path.
  */
 static int
-atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char ** errno_provenance)
+atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, const char ** errno_provenance)
 {
   char template[MAX_CACHEPATH_SIZE + 20];
   char * tmp_path;
-  int fd, ret;
+  int fd, ret, attempt;
   ssize_t nwrite;
 
-  tmp_path = strncpy(template, path, MAX_CACHEPATH_SIZE);
-  strcat(tmp_path, ".tmp.XXXXXX");
+  for (attempt = 0; attempt < MAX_CREATE_TEMPFILE_ATTEMPT; ++attempt) {
+    tmp_path = strncpy(template, path, MAX_CACHEPATH_SIZE);
+    strcat(tmp_path, ".tmp.XXXXXX");
 
-  // mkstemp modifies the template to be the actual created path
-  fd = mkstemp(tmp_path);
-  if (fd < 0) {
-    if (mkpath(tmp_path, 0775) < 0) {
-      *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:mkpath";
-      return -1;
-    }
-    fd = open(tmp_path, O_WRONLY | O_CREAT, 0664);
-    if (fd < 0) {
-      *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:open";
+    // mkstemp modifies the template to be the actual created path
+    fd = mkstemp(tmp_path);
+    if (fd > 0) break;
+
+    if (attempt == 0 && mkpath(tmp_path, 0775) < 0) {
+      *errno_provenance = "bs_fetch:atomic_write_cache_file:mkpath";
       return -1;
     }
   }
+  if (fd < 0) {
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:mkstemp";
+    return -1;
+  }
+
+  if (chmod(tmp_path, 0644) < 0) {
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:chmod";
+    return -1;
+  }
+
   #ifdef _WIN32
   setmode(fd, O_BINARY);
   #endif
@@ -500,11 +534,11 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
   key->data_size = RSTRING_LEN(data);
   nwrite = write(fd, key, KEY_SIZE);
   if (nwrite < 0) {
-    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:write";
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:write";
     return -1;
   }
   if (nwrite != KEY_SIZE) {
-    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:keysize";
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:keysize";
     errno = EIO; /* Lies but whatever */
     return -1;
   }
@@ -512,7 +546,7 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
   nwrite = write(fd, RSTRING_PTR(data), RSTRING_LEN(data));
   if (nwrite < 0) return -1;
   if (nwrite != RSTRING_LEN(data)) {
-    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:writelength";
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:writelength";
     errno = EIO; /* Lies but whatever */
     return -1;
   }
@@ -520,12 +554,12 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
   close(fd);
   ret = rename(tmp_path, path);
   if (ret < 0) {
-    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:rename";
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:rename";
     return -1;
   }
   ret = chmod(path, 0664 & ~current_umask);
   if (ret < 0) {
-    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:chmod";
+    *errno_provenance = "bs_fetch:atomic_write_cache_file:chmod";
   }
   return ret;
 }
@@ -534,13 +568,13 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char
 /* Read contents from an fd, whose contents are asserted to be +size+ bytes
  * long, into a buffer */
 static ssize_t
-bs_read_contents(int fd, size_t size, char ** contents, char ** errno_provenance)
+bs_read_contents(int fd, size_t size, char ** contents, const char ** errno_provenance)
 {
   ssize_t nread;
   *contents = ALLOC_N(char, size);
   nread = read(fd, *contents, size);
   if (nread < 0) {
-    *errno_provenance = (char *)"bs_fetch:bs_read_contents:read";
+    *errno_provenance = "bs_fetch:bs_read_contents:read";
   }
   return nread;
 }
@@ -596,7 +630,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
   char * contents = NULL;
   int cache_fd = -1, current_fd = -1;
   int res, valid_cache = 0, exception_tag = 0;
-  char * errno_provenance = NULL;
+  const char * errno_provenance = NULL;
 
   VALUE input_data;   /* data read from source file, e.g. YAML or ruby source */
   VALUE storage_data; /* compiled data, e.g. msgpack / binary iseq */
@@ -664,7 +698,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
    * using input_to_output */
   if (NIL_P(output_data)) {
     if (unlink(cache_path) < 0) {
-      errno_provenance = (char *)"bs_fetch:unlink";
+      errno_provenance = "bs_fetch:unlink";
       goto fail_errno;
     }
     bs_input_to_output(handler, input_data, &output_data, &exception_tag);
@@ -775,7 +809,7 @@ try_input_to_storage(VALUE arg)
 }
 
 static VALUE
-rescue_input_to_storage(VALUE arg)
+rescue_input_to_storage(VALUE arg, VALUE e)
 {
   return uncompilable;
 }

data/ext/bootsnap/extconf.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require("mkmf")
 $CFLAGS << ' -O3 '
 $CFLAGS << ' -std=c99'

data/lib/bootsnap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('bootsnap/version')
 require_relative('bootsnap/bundler')
 require_relative('bootsnap/load_path_cache')

data/lib/bootsnap/bundler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   extend(self)
 

data/lib/bootsnap/compile_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module CompileCache
     Error           = Class.new(StandardError)
@@ -28,7 +29,7 @@ module Bootsnap
       raise(
         PermissionError,
         "bootsnap doesn't have permission to write cache entries in '#{cpath}' " \
-        "(or, less likely, doesn't have permisison to read '#{path}')",
+        "(or, less likely, doesn't have permission to read '#{path}')",
       )
     end
 

data/lib/bootsnap/compile_cache/iseq.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require('bootsnap/bootsnap')
 require('zlib')
 

data/lib/bootsnap/compile_cache/yaml.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require('bootsnap/bootsnap')
 
 module Bootsnap

data/lib/bootsnap/explicit_require.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module ExplicitRequire
     ARCHDIR    = RbConfig::CONFIG['archdir']

data/lib/bootsnap/load_path_cache/cache.rb

@@ -46,7 +46,7 @@ module Bootsnap
       # loadpath.
       def find(feature)
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
-        feature = feature.to_s
+        feature = feature.to_s.freeze
         return feature if absolute_path?(feature)
         return expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
@@ -67,7 +67,7 @@ module Bootsnap
           # native dynamic extension, e.g. .bundle or .so), we know it was a
           # failure and there's nothing more we can do to find the file.
           # no extension, .rb, (.bundle or .so)
-          when '', *CACHED_EXTENSIONS # rubocop:disable Performance/CaseWhenSplat
+          when '', *CACHED_EXTENSIONS
             nil
           # Ruby allows specifying native extensions as '.so' even when DLEXT
           # is '.bundle'. This is where we handle that case.
@@ -144,7 +144,7 @@ module Bootsnap
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # push -> low precedence -> set only if unset
-            dirs.each    { |dir| @dirs[dir]  ||= path }
+            dirs.each    { |dir| @dirs[dir] ||= path }
             entries.each { |rel| @index[rel] ||= expanded_path }
           end
         end
@@ -178,25 +178,25 @@ module Bootsnap
 
       if DLEXT2
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index("#{f}#{DLEXT2}") || try_index(f)
         end
 
         def maybe_append_extension(f)
-          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || try_ext(f + DLEXT2) || f
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || try_ext("#{f}#{DLEXT2}") || f
         end
       else
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index(f)
         end
 
         def maybe_append_extension(f)
-          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || f
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || f
         end
       end
 
       def try_index(f)
         if (p = @index[f])
-          p + '/' + f
+          "#{p}/#{f}"
         end
       end