bootsnap 1.1.5 → 1.1.6.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3e149a8eb8efa3469c157ec2858ccfbe1613a84
-  data.tar.gz: eb7b1180fc432ffd80b88849b7ffe7df50fd409e
+  metadata.gz: 269514b76977fe302e8e8bed9059ead9a2c9cf28
+  data.tar.gz: a66fd4b75f0b4fb211b998ded43f87aa31edc8b4
 SHA512:
-  metadata.gz: dc8848fdac6603869affe7f7329bdf3bf691233fd4031d0d4481cee6190623b4d388a6d868bca7d7f49ff9da6bd622f8b98a9056314a344ee980103d2ae2d2dc
-  data.tar.gz: 91326a624801bd3c24053bd789a1157d497c35e44a7c5993f06c11f51eadebf3fed8305195e57e3d8e907415875763c592e6772842692c6155ff0f60d4f6dbf0
+  metadata.gz: e3651625736c73f66e3380c5ca1514769707d5d605541a6f636c9fbb563cc2b3199bfc5baa26130106a158f02f66485bdd606f7db5ee47914e451a7ff4337f0d
+  data.tar.gz: e0ba55c3d695a8d91b4ba2aa0ca120ba530c7a665e66a882b8f1e966e846639399e5ea49cecc08aec7ba36b1329b08c84140e20f3aa34efa2902e4b35ebc0681

data/.travis.yml

@@ -1,5 +1,4 @@
-os: osx
 language: ruby
-rvm: ruby-2.4.0
+rvm: ruby-2.4.1
 before_script: rake
 script: bin/testunit

data/README.md

@@ -1,7 +1,5 @@
 # Bootsnap [![Build Status](https://travis-ci.org/Shopify/bootsnap.svg?branch=master)](https://travis-ci.org/Shopify/bootsnap)
 
-**Beta-quality. See [the last section of this README](#trustworthiness).**
-
 Bootsnap is a library that plugs into Ruby, with optional support for `ActiveSupport` and `YAML`,
 to optimize and cache expensive computations. See [How Does This Work](#how-does-this-work).
 
@@ -48,6 +46,11 @@ Bootsnap.setup(
 'bootsnap')` using [this trick](https://github.com/Shopify/bootsnap/wiki/Bootlib::Require). This
 will help optimize boot time further if you have an extremely large `$LOAD_PATH`.
 
+Note: Bootsnap and [Spring](https://github.com/rails/spring) are orthogonal tools. While Bootsnap
+speeds up the loading of individual source files, Spring keeps a copy of a pre-booted Rails process
+on hand to completely skip parts of the boot process the next time it's needed. The two tools work
+well together, and are both included in a newly-generated Rails applications by default. 
+
 ## How does this work?
 
 Bootsnap optimizes methods to cache results of expensive computations, and can be grouped
@@ -264,21 +267,3 @@ open    /c/nope.bundle -> -1
 ```
 # (nothing!)
 ```
-
-## Trustworthiness
-
-We use the `*_path_cache` features in production and haven't experienced any issues in a long time.
-
-The `compile_cache_*` features work well for us in development on macOS. It should work on Linux,
-and we intend to deploy it in production, but we haven't yet.
-
-`disable_trace` should be completely safe, but we don't really use it because some people like to
-use tools that make use of `trace` instructions.
-
-| feature | where we're using it |
-|-|-|
-| `load_path_cache` | everywhere |
-| `autoload_path_cache` | everywhere |
-| `disable_trace` | nowhere, but it's safe unless you need tracing |
-| `compile_cache_iseq` | development, but probably safe to use everywhere |
-| `compile_cache_yaml` | development, but probably safe to use everywhere |

data/dev.yml

@@ -5,5 +5,6 @@ up:
   - ruby: 2.3.3
   - bundler
 commands:
+  build: rake compile
   test: 'rake compile && exec bin/testunit'
   style: 'exec rubocop -D'

data/ext/bootsnap/bootsnap.c

@@ -92,8 +92,8 @@ static void bs_cache_path(const char * cachedir, const char * path, char ** cach
 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);
-static int fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag);
+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 VALUE prot_exception_for_errno(VALUE err);
 static uint32_t get_os_version(void);
 
@@ -279,18 +279,22 @@ 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)
+open_current_file(char * path, struct bs_cache_key * key, char ** errno_provenance)
 {
   struct stat statbuf;
   int fd;
 
   fd = open(path, O_RDONLY);
-  if (fd < 0) return fd;
+  if (fd < 0) {
+    *errno_provenance = (char *)"bs_fetch:open_current_file:open";
+    return fd;
+  }
   #ifdef _WIN32
   setmode(fd, O_BINARY);
   #endif
 
   if (fstat(fd, &statbuf) < 0) {
+    *errno_provenance = (char *)"bs_fetch:open_current_file:fstat";
     close(fd);
     return -1;
   }
@@ -336,12 +340,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)
+open_cache_file(const char * path, struct bs_cache_key * key, char ** errno_provenance)
 {
   int fd, res;
 
   fd = open(path, O_RDONLY);
   if (fd < 0) {
+    *errno_provenance = (char *)"bs_fetch:open_cache_file:open";
     if (errno == ENOENT) return CACHE_MISSING_OR_INVALID;
     return ERROR_WITH_ERRNO;
   }
@@ -351,6 +356,7 @@ open_cache_file(const char * path, struct bs_cache_key * key)
 
   res = bs_read_key(fd, key);
   if (res < 0) {
+    *errno_provenance = (char *)"bs_fetch:open_cache_file:read";
     close(fd);
     return res;
   }
@@ -374,7 +380,7 @@ open_cache_file(const char * path, struct bs_cache_key * key)
  * 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)
+fetch_cached_data(int fd, ssize_t data_size, VALUE handler, VALUE * output_data, int * exception_tag, char ** errno_provenance)
 {
   char * data = NULL;
   ssize_t nread;
@@ -383,6 +389,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 = EINVAL; /* because wtf? */
     ret = -1;
     goto done;
@@ -390,6 +397,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";
     ret = -1;
     goto done;
   }
@@ -441,12 +449,12 @@ mkpath(char * file_path, mode_t mode)
  * path.
  */
 static int
-atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data)
+atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data, char ** errno_provenance)
 {
   char template[MAX_CACHEPATH_SIZE + 20];
   char * dest;
   char * tmp_path;
-  int fd;
+  int fd, ret;
   ssize_t nwrite;
 
   dest = strncpy(template, path, MAX_CACHEPATH_SIZE);
@@ -455,9 +463,15 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data)
   tmp_path = mktemp(template);
   fd = open(tmp_path, O_WRONLY | O_CREAT, 0644);
   if (fd < 0) {
-    if (mkpath(path, 0755) < 0) return -1;
+    if (mkpath(path, 0755) < 0) {
+      *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:mkpath";
+      return -1;
+    }
     fd = open(tmp_path, O_WRONLY | O_CREAT, 0644);
-    if (fd < 0) return -1;
+    if (fd < 0) {
+      *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:open";
+      return -1;
+    }
   }
   #ifdef _WIN32
   setmode(fd, O_BINARY);
@@ -465,8 +479,12 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data)
 
   key->data_size = RSTRING_LEN(data);
   nwrite = write(fd, key, KEY_SIZE);
-  if (nwrite < 0) return -1;
+  if (nwrite < 0) {
+    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:write";
+    return -1;
+  }
   if (nwrite != KEY_SIZE) {
+    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:keysize";
     errno = EIO; /* Lies but whatever */
     return -1;
   }
@@ -474,12 +492,17 @@ atomic_write_cache_file(char * path, struct bs_cache_key * key, VALUE data)
   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 = EIO; /* Lies but whatever */
     return -1;
   }
 
   close(fd);
-  return rename(tmp_path, path);
+  ret = rename(tmp_path, path);
+  if (ret < 0) {
+    *errno_provenance = (char *)"bs_fetch:atomic_write_cache_file:rename";
+  }
+  return ret;
 }
 
 /*
@@ -502,10 +525,15 @@ prot_exception_for_errno(VALUE err)
 /* 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)
+bs_read_contents(int fd, size_t size, char ** contents, char ** errno_provenance)
 {
+  ssize_t nread;
   *contents = ALLOC_N(char, size);
-  return read(fd, *contents, size);
+  nread = read(fd, *contents, size);
+  if (nread < 0) {
+    *errno_provenance = (char *)"bs_fetch:bs_read_contents:read";
+  }
+  return nread;
 }
 
 /*
@@ -513,24 +541,24 @@ bs_read_contents(int fd, size_t size, char ** contents)
  * Bootsnap::CompileCache::Native.fetch.
  *
  * There are three "formats" in use here:
- *   1. "input" fomat, which is what we load from the source file;
+ *   1. "input" format, which is what we load from the source file;
  *   2. "storage" format, which we write to the cache;
  *   3. "output" format, which is what we return.
  *
  * E.g., For ISeq compilation:
- *   input: ruby source, as text
+ *   input:   ruby source, as text
  *   storage: binary string (RubyVM::InstructionSequence#to_binary)
- *   output: Instance of RubyVM::InstructionSequence
+ *   output:  Instance of RubyVM::InstructionSequence
  *
  * And for YAML:
- *   input: yaml as text
+ *   input:   yaml as text
  *   storage: MessagePack or Marshal text
- *   output: ruby object, loaded from yaml/messagepack/marshal
+ *   output:  ruby object, loaded from yaml/messagepack/marshal
  *
- * The handler passed in must support three messages:
- *   * storage_to_output(s) -> o
- *   * input_to_output(i)   -> o
- *   * input_to_storage(i)  -> s
+ * A handler<I,S,O> passed in must support three messages:
+ *   * storage_to_output(S) -> O
+ *   * input_to_output(I)   -> O
+ *   * input_to_storage(I)  -> S
  *     (input_to_storage may raise Bootsnap::CompileCache::Uncompilable, which
  *     will prevent caching and cause output to be generated with
  *     input_to_output)
@@ -559,6 +587,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, exception_tag = 0;
+  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 */
@@ -567,11 +596,11 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
   VALUE exception; /* ruby exception object to raise instead of returning */
 
   /* Open the source file and generate a cache key for it */
-  current_fd = open_current_file(path, &current_key);
+  current_fd = open_current_file(path, &current_key, &errno_provenance);
   if (current_fd < 0) goto fail_errno;
 
   /* Open the cache key if it exists, and read its cache key in */
-  cache_fd = open_cache_file(cache_path, &cached_key);
+  cache_fd = open_cache_file(cache_path, &cached_key, &errno_provenance);
   if (cache_fd < 0 && cache_fd != CACHE_MISSING_OR_INVALID) goto fail_errno;
 
   /* True if the cache existed and no invalidating changes have occurred since
@@ -580,7 +609,10 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
 
   if (valid_cache) {
     /* Fetch the cache data and return it if we're able to load it successfully */
-    res = fetch_cached_data(cache_fd, (ssize_t)cached_key.data_size, handler, &output_data, &exception_tag);
+    res = fetch_cached_data(
+      cache_fd, (ssize_t)cached_key.data_size, handler,
+      &output_data, &exception_tag, &errno_provenance
+    );
     if (exception_tag != 0)                   goto raise;
     else if (res == CACHE_MISSING_OR_INVALID) valid_cache = 0;
     else if (res == ERROR_WITH_ERRNO)         goto fail_errno;
@@ -591,7 +623,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
   /* Cache is stale, invalid, or missing. Regenerate and write it out. */
 
   /* Read the contents of the source file into a buffer */
-  if (bs_read_contents(current_fd, current_key.size, &contents) < 0) goto fail_errno;
+  if (bs_read_contents(current_fd, current_key.size, &contents, &errno_provenance) < 0) goto fail_errno;
   input_data = rb_str_new_static(contents, current_key.size);
 
   /* Try to compile the input_data using input_to_storage(input_data) */
@@ -608,7 +640,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
   if (!RB_TYPE_P(storage_data, T_STRING)) goto invalid_type_storage_data;
 
   /* Write the cache key and storage_data to the cache directory */
-  res = atomic_write_cache_file(cache_path, &current_key, storage_data);
+  res = atomic_write_cache_file(cache_path, &current_key, storage_data, &errno_provenance);
   if (res < 0) goto fail_errno;
 
   /* Having written the cache, now convert storage_data to output_data */
@@ -618,7 +650,10 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler)
   /* If output_data is nil, delete the cache entry and generate the output
    * using input_to_output */
   if (NIL_P(output_data)) {
-    if (unlink(cache_path) < 0) goto fail_errno;
+    if (unlink(cache_path) < 0) {
+      errno_provenance = (char *)"bs_fetch:unlink";
+      goto fail_errno;
+    }
     bs_input_to_output(handler, input_data, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
   }
@@ -637,6 +672,9 @@ fail_errno:
   CLEANUP;
   exception = rb_protect(prot_exception_for_errno, INT2FIX(errno), &res);
   if (res) exception = rb_eStandardError;
+  if (errno_provenance != NULL) {
+    exception = rb_exc_new_str(exception, rb_str_new2(errno_provenance));
+  }
   rb_exc_raise(exception);
   __builtin_unreachable();
 raise:
@@ -655,7 +693,17 @@ invalid_type_storage_data:
 /********************* Handler Wrappers **************************************/
 /*****************************************************************************
  * Everything after this point in the file is just wrappers to deal with ruby's
- * clunky method of handling exceptions from ruby methods invoked from C.
+ * clunky method of handling exceptions from ruby methods invoked from C:
+ *
+ * In order to call a ruby method from C, while protecting against crashing in
+ * the event of an exception, we must call the method with rb_protect().
+ *
+ * rb_protect takes a C function and precisely one argument; however, we want
+ * to pass multiple arguments, so we must create structs to wrap them up.
+ *
+ * These functions return an exception_tag, which, if non-zero, indicates an
+ * exception that should be jumped to with rb_jump_tag after cleaning up
+ * allocated resources.
  */
 
 struct s2o_data {

data/lib/bootsnap/bundler.rb

@@ -0,0 +1,12 @@
+module Bootsnap
+  module_function
+
+  def bundler?
+    # Bundler environment variable
+    ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+      return true if ENV.key?(current)
+    end
+    
+    false
+  end
+end

data/lib/bootsnap/load_path_cache/core_ext/active_support.rb

@@ -45,6 +45,10 @@ module Bootsnap
             # NoMethodError is a NameError, but we only want to handle actual
             # NameError instances.
             raise unless e.class == NameError
+            # We can only confidently handle cases when *this* constant fails
+            # to load, not other constants referred to by it.
+            raise unless e.name == const_name
+            # If the constant was actually loaded, something else went wrong?
             raise if from_mod.const_defined?(const_name)
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end

data/lib/bootsnap/load_path_cache/path.rb

@@ -99,7 +99,7 @@ module Bootsnap
         @stability ||= begin
           if Gem.path.detect { |p| expanded_path.start_with?(p.to_s) }
             STABLE
-          elsif expanded_path.start_with?(Bundler.bundle_path.to_s)
+          elsif Bootsnap.bundler? && expanded_path.start_with?(Bundler.bundle_path.to_s)
             STABLE
           elsif expanded_path.start_with?(RUBY_LIBDIR) && !expanded_path.start_with?(RUBY_SITEDIR)
             STABLE

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -15,7 +15,8 @@ module Bootsnap
       REQUIRABLES_AND_DIRS = "/{,*/**/}*{#{DOT_RB},#{DL_EXTENSIONS.join(',')},/}"
       NORMALIZE_NATIVE_EXTENSIONS = !DL_EXTENSIONS.include?(LoadPathCache::DOT_SO)
       ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/
-      BUNDLE_PATH = (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
+      BUNDLE_PATH = Bootsnap.bundler? ?
+        (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze : ''.freeze
 
       def self.call(path)
         path = path.to_s

data/lib/bootsnap/setup.rb

@@ -4,16 +4,10 @@ env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['ENV']
 development_mode = ['', nil, 'development'].include?(env)
 
 # only enable on 'ruby' (MRI), POSIX (darin, linux, *bsd), and >= 2.3.0
-enable_cc = \
-  RUBY_ENGINE == 'ruby' && \
-  RUBY_PLATFORM =~ /darwin|linux|bsd/ && \
-  RUBY_VERSION                    # "1.9.3"
-    .split('.')                   # ["1", "9", "3"]
-    .map(&:to_i)                  # [1, 9, 3]
-    .zip([2, 3, -1])              # [[1, 2], [9, 3], [3, -1]]
-    .map { |a, b| a <=> b }       # [-1, 1, 1]
-    .detect { |e| !e.zero? }      # -1
-    .==(1)                        # false
+enable_cc =
+  RUBY_ENGINE == 'ruby' &&
+  RUBY_PLATFORM =~ /darwin|linux|bsd/ &&
+  Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
 
 cache_dir = ENV['BOOTSNAP_CACHE_DIR']
 unless cache_dir

data/lib/bootsnap/version.rb

@@ -1,3 +1,3 @@
 module Bootsnap
-  VERSION = "1.1.5"
+  VERSION = "1.1.6.beta2"
 end

data/lib/bootsnap.rb

@@ -1,4 +1,5 @@
 require_relative 'bootsnap/version'
+require_relative 'bootsnap/bundler'
 require_relative 'bootsnap/load_path_cache'
 require_relative 'bootsnap/compile_cache'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6.beta2
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-06 00:00:00.000000000 Z
+date: 2017-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -121,6 +121,7 @@ files:
 - ext/bootsnap/bootsnap.h
 - ext/bootsnap/extconf.rb
 - lib/bootsnap.rb
+- lib/bootsnap/bundler.rb
 - lib/bootsnap/compile_cache.rb
 - lib/bootsnap/compile_cache/iseq.rb
 - lib/bootsnap/compile_cache/yaml.rb
@@ -150,12 +151,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Boot large ruby/rails apps faster