Class: MiniRacer::Context

Inherits:

Object

• Object
• MiniRacer::Context

Defined in:

lib/mini_racer.rb

Overview

eval is defined in the C class

Defined Under Namespace

Classes: ExternalFunction

Instance Method Summary

• #attach(name, callback) ⇒ Object
• #call(function_name, *arguments) ⇒ Object
• #dispose ⇒ Object
• #eval(str, options = nil) ⇒ Object
• #initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil) ⇒ Context constructor

  A new instance of Context.

• #isolate ⇒ Object
• #load(filename) ⇒ Object
• #write_heap_snapshot(file_or_io) ⇒ Object

Constructor Details

#initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil) ⇒ Context

Returns a new instance of Context.

# File 'lib/mini_racer.rb', line 143

def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil)
  options ||= {}

  check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)

  @functions = {}
  @timeout = nil
  @max_memory = nil
  @current_exception = nil
  @timeout = timeout
  @max_memory = max_memory

  # false signals it should be fetched if requested
  @isolate = isolate || false

  @ensure_gc_after_idle = ensure_gc_after_idle

  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

Instance Method Details

#attach(name, callback) ⇒ Object

Raises:

• (ContextDisposedError)

# File 'lib/mini_racer.rb', line 252

def attach(name, callback)
  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

#call(function_name, *arguments) ⇒ Object

# File 'lib/mini_racer.rb', line 227

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

#dispose ⇒ Object

# File 'lib/mini_racer.rb', line 241

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

#eval(str, options = nil) ⇒ Object

# File 'lib/mini_racer.rb', line 210

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
    timeout do
      eval_unsafe(str, filename)
    end
  end
ensure
  @eval_thread = nil
  ensure_gc_thread if @ensure_gc_after_idle
end

#isolate ⇒ Object

# File 'lib/mini_racer.rb', line 177

def isolate
  return @isolate if @isolate != false
  # defined in the C class
  @isolate = create_isolate_value
end

#load(filename) ⇒ Object

# File 'lib/mini_racer.rb', line 183

def load(filename)
  # TODO do this native cause no need to allocate VALUE here
  eval(File.read(filename))
end

#write_heap_snapshot(file_or_io) ⇒ Object

# File 'lib/mini_racer.rb', line 188

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