mini_racer 0.1.0 → 0.6.0

data/ext/mini_racer_loader/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+extension_name = 'mini_racer_loader'
+dir_config extension_name
+
+$CXXFLAGS += " -fvisibility=hidden "
+
+create_makefile extension_name

data/ext/mini_racer_loader/mini_racer_loader.c

@@ -0,0 +1,123 @@
+#include <ruby.h>
+#include <dlfcn.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+// Load a Ruby extension like Ruby does, only with flags that:
+// a) hide symbols from other extensions (RTLD_LOCAL)
+// b) bind symbols tightly (RTLD_DEEPBIND, when available)
+
+void Init_mini_racer_loader(void);
+
+static void *_dln_load(const char *file);
+
+static VALUE _load_shared_lib(VALUE self, volatile VALUE fname)
+{
+    (void) self;
+
+    // check that path is not tainted
+    SafeStringValue(fname);
+
+    FilePathValue(fname);
+    VALUE path = rb_str_encode_ospath(fname);
+
+    char *loc = StringValueCStr(path);
+    void *handle = _dln_load(loc);
+
+    return handle ? Qtrue : Qfalse;
+}
+
+// adapted from Ruby's dln.c
+#define INIT_FUNC_PREFIX ((char[]) {'I', 'n', 'i', 't', '_'})
+#define INIT_FUNCNAME(buf, file) do { \
+    const char *base = (file); \
+    const size_t flen = _init_funcname(&base); \
+    const size_t plen = sizeof(INIT_FUNC_PREFIX); \
+    char *const tmp = ALLOCA_N(char, plen + flen + 1); \
+    memcpy(tmp, INIT_FUNC_PREFIX, plen); \
+    memcpy(tmp+plen, base, flen); \
+    tmp[plen+flen] = '\0'; \
+    *(buf) = tmp; \
+} while(0)
+
+// adapted from Ruby's dln.c
+static size_t _init_funcname(const char **file)
+{
+    const char *p = *file,
+               *base,
+               *dot = NULL;
+
+    for (base = p; *p; p++) { /* Find position of last '/' */
+        if (*p == '.' && !dot) {
+            dot = p;
+        }
+        if (*p == '/') {
+            base = p + 1;
+            dot = NULL;
+        }
+    }
+    *file = base;
+    return (uintptr_t) ((dot ? dot : p) - base);
+}
+
+// adapted from Ruby's dln.c
+static void *_dln_load(const char *file)
+{
+    char *buf;
+    const char *error;
+#define DLN_ERROR() (error = dlerror(), strcpy(ALLOCA_N(char, strlen(error) + 1), error))
+
+    void *handle;
+    void (*init_fct)(void);
+
+    INIT_FUNCNAME(&buf, file);
+
+#ifndef RTLD_DEEPBIND
+# define RTLD_DEEPBIND 0
+#endif
+    /* Load file */
+    if ((handle = dlopen(file, RTLD_LAZY|RTLD_LOCAL|RTLD_DEEPBIND)) == NULL) {
+        DLN_ERROR();
+        goto failed;
+    }
+#if defined(RUBY_EXPORT)
+    {
+        static const char incompatible[] = "incompatible library version";
+        void *ex = dlsym(handle, "ruby_xmalloc");
+        if (ex && ex != (void *) &ruby_xmalloc) {
+
+# if defined __APPLE__
+            /* dlclose() segfaults */
+            rb_fatal("%s - %s", incompatible, file);
+# else
+            dlclose(handle);
+            error = incompatible;
+            goto failed;
+#endif
+        }
+    }
+# endif
+
+    init_fct = (void (*)(void)) dlsym(handle, buf);
+    if (init_fct == NULL) {
+        error = DLN_ERROR();
+        dlclose(handle);
+        goto failed;
+    }
+
+    /* Call the init code */
+    (*init_fct)();
+
+    return handle;
+
+failed:
+    rb_raise(rb_eLoadError, "%s", error);
+}
+
+__attribute__((visibility("default"))) void Init_mini_racer_loader()
+{
+    VALUE mMiniRacer = rb_define_module("MiniRacer");
+    VALUE mLoader = rb_define_module_under(mMiniRacer, "Loader");
+    rb_define_singleton_method(mLoader, "load", _load_shared_lib, 1);
+}

data/lib/mini_racer/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module MiniRacer
-  VERSION = "0.1.0"
+  VERSION = "0.6.0"
+  LIBV8_NODE_VERSION = "~> 16.10.0.0"
 end

data/lib/mini_racer.rb

@@ -1,13 +1,40 @@
 require "mini_racer/version"
-require "mini_racer_extension"
+require "mini_racer_loader"
+require "pathname"
+
+ext_filename = "mini_racer_extension.#{RbConfig::CONFIG['DLEXT']}"
+ext_path = Gem.loaded_specs['mini_racer'].require_paths
+  .map { |p| (p = Pathname.new(p)).absolute? ? p : Pathname.new(__dir__).parent + p }
+ext_found = ext_path.map { |p| p + ext_filename }.find { |p| p.file? }
+
+raise LoadError, "Could not find #{ext_filename} in #{ext_path.map(&:to_s)}" unless ext_found
+MiniRacer::Loader.load(ext_found.to_s)
+
 require "thread"
+require "json"
 
 module MiniRacer
 
-  class EvalError < StandardError; end
+  MARSHAL_STACKDEPTH_DEFAULT = 2**9-2
+  MARSHAL_STACKDEPTH_MAX_VALUE = 2**10-2
 
-  class ScriptTerminatedError < EvalError; end
+  class Error < ::StandardError; end
+
+  class ContextDisposedError < Error; end
+  class SnapshotError < Error; end
+  class PlatformAlreadyInitialized < Error; end
+
+  class EvalError < Error; end
   class ParseError < EvalError; end
+  class ScriptTerminatedError < EvalError; end
+  class V8OutOfMemoryError < EvalError; end
+
+  class FailedV8Conversion
+    attr_reader :info
+    def initialize(info)
+      @info = info
+    end
+  end
 
   class RuntimeError < EvalError
     def initialize(message)
@@ -18,7 +45,6 @@ module MiniRacer
       else
         @js_backtrace = nil
       end
-
       super(message)
     end
 
@@ -31,7 +57,6 @@ module MiniRacer
         val
       end
     end
-
   end
 
   # helper class returned when we have a JavaScript function
@@ -41,44 +66,388 @@ module MiniRacer
     end
   end
 
+  class Isolate
+    def initialize(snapshot = nil)
+      unless snapshot.nil? || snapshot.is_a?(Snapshot)
+        raise ArgumentError, "snapshot must be a Snapshot object, passed a #{snapshot.inspect}"
+      end
+
+      # defined in the C class
+      init_with_snapshot(snapshot)
+    end
+  end
+
+  class Platform
+    class << self
+      def set_flags!(*args, **kwargs)
+        flags_to_strings([args, kwargs]).each do |flag|
+          # defined in the C class
+          set_flag_as_str!(flag)
+        end
+      end
+
+    private
+
+      def flags_to_strings(flags)
+        flags.flatten.map { |flag| flag_to_string(flag) }.flatten
+      end
+
+      # normalize flags to strings, and adds leading dashes if needed
+      def flag_to_string(flag)
+        if flag.is_a?(Hash)
+          flag.map do |key, value|
+            "#{flag_to_string(key)} #{value}"
+          end
+        else
+          str = flag.to_s
+          str = "--#{str}" unless str.start_with?('--')
+          str
+        end
+      end
+    end
+  end
+
   # eval is defined in the C class
   class Context
 
     class ExternalFunction
       def initialize(name, callback, parent)
-        @name = name
+        unless String === name
+          raise ArgumentError, "parent_object must be a String"
+        end
+        parent_object, _ , @name = name.rpartition(".")
         @callback = callback
         @parent = parent
+        @parent_object_eval = nil
+        @parent_object = nil
+
+        unless parent_object.empty?
+          @parent_object = parent_object
+
+          @parent_object_eval = ""
+          prev = ""
+          first = true
+          parent_object.split(".").each do |obj|
+            prev << obj
+            if first
+              @parent_object_eval << "if (typeof #{prev} === 'undefined') { #{prev} = {} };\n"
+            else
+              @parent_object_eval << "#{prev} = #{prev} || {};\n"
+            end
+            prev << "."
+            first = false
+          end
+          @parent_object_eval << "#{parent_object};"
+        end
         notify_v8
       end
     end
 
-    def initialize(options = nil)
+    def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil, marshal_stack_depth: nil)
+      options ||= {}
+
+      check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, marshal_stack_depth: marshal_stack_depth, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)
+
       @functions = {}
-      @lock = Mutex.new
       @timeout = nil
+      @max_memory = nil
       @current_exception = nil
+      @timeout = timeout
+      @max_memory = max_memory
+      @marshal_stack_depth = marshal_stack_depth
+
+      # false signals it should be fetched if requested
+      @isolate = isolate || false
+
+      @ensure_gc_after_idle = ensure_gc_after_idle
 
-      if options
-        @timeout = options[:timeout]
+      if @ensure_gc_after_idle
+        @last_eval = nil
+        @ensure_gc_thread = nil
+        @ensure_gc_mutex = Mutex.new
       end
 
+      @disposed = false
+
+      @callback_mutex = Mutex.new
+      @callback_running = false
+      @thread_raise_called = false
+      @eval_thread = nil
+
+      # defined in the C class
+      init_unsafe(isolate, snapshot)
+    end
+
+    def isolate
+      return @isolate if @isolate != false
+      # defined in the C class
+      @isolate = create_isolate_value
+    end
+
+    def load(filename)
+      # TODO do this native cause no need to allocate VALUE here
+      eval(File.read(filename))
     end
 
-    def eval(str)
-      @lock.synchronize do
+    def write_heap_snapshot(file_or_io)
+      f = nil
+      implicit = false
+
+
+      if String === file_or_io
+        f = File.open(file_or_io, "w")
+        implicit = true
+      else
+        f = file_or_io
+      end
+
+      if !(File === f)
+        raise ArgumentError("file_or_io")
+      end
+
+      write_heap_snapshot_unsafe(f)
+
+    ensure
+      f.close if implicit
+    end
+
+    def eval(str, options=nil)
+      raise(ContextDisposedError, 'attempted to call eval on a disposed context!') if @disposed
+
+      filename = options && options[:filename].to_s
+
+      @eval_thread = Thread.current
+      isolate_mutex.synchronize do
         @current_exception = nil
-        eval_unsafe(str)
+        timeout do
+          eval_unsafe(str, filename)
+        end
+      end
+    ensure
+      @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
+    end
+
+    def call(function_name, *arguments)
+      raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed
+
+      @eval_thread = Thread.current
+      isolate_mutex.synchronize do
+        timeout do
+          call_unsafe(function_name, *arguments)
+        end
       end
+    ensure
+      @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
     end
 
+    def dispose
+      return if @disposed
+      isolate_mutex.synchronize do
+        return if @disposed
+        dispose_unsafe
+        @disposed = true
+        @isolate = nil # allow it to be garbage collected, if set
+      end
+    end
+
+
     def attach(name, callback)
-      @lock.synchronize do
-        external = ExternalFunction.new(name, callback, self)
-        @functions[name.to_s] = external
+      raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed
+
+      wrapped = lambda do |*args|
+        begin
+
+          r = nil
+
+          begin
+            @callback_mutex.synchronize{
+              @callback_running = true
+            }
+            r = callback.call(*args)
+          ensure
+            @callback_mutex.synchronize{
+              @callback_running = false
+            }
+          end
+
+          # wait up to 2 seconds for this to be interrupted
+          # will very rarely be called cause #raise is called
+          # in another mutex
+          @callback_mutex.synchronize {
+            if @thread_raise_called
+              sleep 2
+            end
+          }
+
+          r
+
+        ensure
+          @callback_mutex.synchronize {
+            @thread_raise_called = false
+          }
+        end
+      end
+
+      isolate_mutex.synchronize do
+        external = ExternalFunction.new(name, wrapped, self)
+        @functions["#{name}"] = external
+      end
+    end
+
+  private
+
+    def ensure_gc_thread
+      @last_eval = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @ensure_gc_mutex.synchronize do
+        @ensure_gc_thread = nil if !@ensure_gc_thread&.alive?
+        @ensure_gc_thread ||= Thread.new do
+          ensure_gc_after_idle_seconds = @ensure_gc_after_idle / 1000.0
+          done = false
+          while !done
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            if @disposed
+              @ensure_gc_thread = nil
+              break
+            end
+
+            if !@eval_thread && ensure_gc_after_idle_seconds < now - @last_eval
+              @ensure_gc_mutex.synchronize do
+                isolate_mutex.synchronize do
+                  if !@eval_thread
+                    isolate.low_memory_notification if !@disposed
+                    @ensure_gc_thread = nil
+                    done = true
+                  end
+                end
+              end
+            end
+            sleep ensure_gc_after_idle_seconds if !done
+          end
+        end
+      end
+    end
+
+    def stop_attached
+      @callback_mutex.synchronize{
+        if @callback_running
+          @eval_thread.raise ScriptTerminatedError, "Terminated during callback"
+          @thread_raise_called = true
+        end
+      }
+    end
+
+    def timeout(&blk)
+      return blk.call unless @timeout
+
+      mutex = Mutex.new
+      done = false
+
+      rp,wp = IO.pipe
+
+      t = Thread.new do
+        begin
+          result = IO.select([rp],[],[],(@timeout/1000.0))
+          if !result
+            mutex.synchronize do
+              stop unless done
+            end
+          end
+        rescue => e
+          STDERR.puts e
+          STDERR.puts "FAILED TO TERMINATE DUE TO TIMEOUT"
+        end
+      end
+
+      rval = blk.call
+      mutex.synchronize do
+        done = true
+      end
+
+      wp.write("done")
+
+      # ensure we do not leak a thread in state
+      t.join
+      t = nil
+
+      rval
+    ensure
+      # exceptions need to be handled
+      if t && wp
+        wp.write("done")
+        t.join
+      end
+      wp.close if wp
+      rp.close if rp
+    end
+
+    def check_init_options!(isolate:, snapshot:, max_memory:, marshal_stack_depth:, ensure_gc_after_idle:, timeout:)
+      assert_option_is_nil_or_a('isolate', isolate, Isolate)
+      assert_option_is_nil_or_a('snapshot', snapshot, Snapshot)
+
+      assert_numeric_or_nil('max_memory', max_memory, min_value: 10_000, max_value: 2**32-1)
+      assert_numeric_or_nil('marshal_stack_depth', marshal_stack_depth, min_value: 1, max_value: MARSHAL_STACKDEPTH_MAX_VALUE)
+      assert_numeric_or_nil('ensure_gc_after_idle', ensure_gc_after_idle, min_value: 1)
+      assert_numeric_or_nil('timeout', timeout, min_value: 1)
+
+      if isolate && snapshot
+        raise ArgumentError, 'can only pass one of isolate and snapshot options'
       end
     end
 
+    def assert_numeric_or_nil(option_name, object, min_value:, max_value: nil)
+      if max_value && object.is_a?(Numeric) && object > max_value
+        raise ArgumentError, "#{option_name} must be less than or equal to #{max_value}"
+      end
+
+      if object.is_a?(Numeric) && object < min_value
+        raise ArgumentError, "#{option_name} must be larger than or equal to #{min_value}"
+      end
+
+      if !object.nil? && !object.is_a?(Numeric)
+        raise ArgumentError, "#{option_name} must be a number, passed a #{object.inspect}"
+      end
+    end
+
+    def assert_option_is_nil_or_a(option_name, object, klass)
+      unless object.nil? || object.is_a?(klass)
+        raise ArgumentError, "#{option_name} must be a #{klass} object, passed a #{object.inspect}"
+      end
+    end
   end
 
+  # `size` and `warmup!` public methods are defined in the C class
+  class Snapshot
+    def initialize(str = '')
+      # ensure it first can load
+      begin
+        ctx = MiniRacer::Context.new
+        ctx.eval(str)
+      rescue MiniRacer::RuntimeError => e
+        raise MiniRacer::SnapshotError.new, e.message, e.backtrace
+      end
+
+      @source = str
+
+      # defined in the C class
+      load(str)
+    end
+
+    def warmup!(src)
+      # we have to do something here
+      # we are bloating memory a bit but it is more correct
+      # than hitting an exception when attempty to compile invalid source
+      begin
+        ctx = MiniRacer::Context.new
+        ctx.eval(@source)
+        ctx.eval(src)
+      rescue MiniRacer::RuntimeError => e
+        raise MiniRacer::SnapshotError.new, e.message, e.backtrace
+      end
+
+      warmup_unsafe!(src)
+    end
+  end
 end

data/mini_racer.gemspec

@@ -11,23 +11,29 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Minimal embedded v8 for Ruby}
   spec.description   = %q{Minimal embedded v8 engine for Ruby}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/discourse/mini_racer"
   spec.license       = "MIT"
 
+  spec.metadata      = {
+    "bug_tracker_uri"   => "https://github.com/discourse/mini_racer/issues",
+    "changelog_uri"     => "https://github.com/discourse/mini_racer/blob/v#{spec.version}/CHANGELOG",
+    "documentation_uri" => "https://www.rubydoc.info/gems/mini_racer/#{spec.version}",
+    "source_code_uri"   => "https://github.com/discourse/mini_racer/tree/v#{spec.version}",
+  }
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(benchmark|test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(benchmark|test|spec|features|examples)/}) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "m"
 
-  spec.add_dependency 'libv8', '~> 5.0'
+  spec.add_dependency 'libv8-node', MiniRacer::LIBV8_NODE_VERSION
   spec.require_paths = ["lib", "ext"]
 
-  spec.extensions = ["ext/mini_racer_extension/extconf.rb"]
+  spec.extensions = ["ext/mini_racer_loader/extconf.rb", "ext/mini_racer_extension/extconf.rb"]
 
+  spec.required_ruby_version = '>= 2.6'
 end