speednode 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ab3e330c3cd4bf4518c54e6666ff13ee722b553e4de7d8be2602b984811da9fc
+  data.tar.gz: '08218aa8e443770808a35de088c869bfc0d227493beba5f60b98ddcdfe35b51a'
+SHA512:
+  metadata.gz: 3f41ebd4a9b509dc81f815c7dff64ff3ce8ae15a57fa085038ce5cdb139ab37f0f0b26cded89f52450e4e39a0f69afd98238a7ed02d20db50e7d395872617f67
+  data.tar.gz: cb7d8667d95403426e7964e4e2be7d1608a3d2ad43fe1b36a694f125bd9595dfe3ba5b73d983d57215fdc637b2a141d8536f642435082005cbbdc5487af1b2e1

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016 John Hawthorn
+Copyright (c) 2019-2024 Jan Biedermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# Speednode
+
+A fast runtime for ExecJS using node js. Works on Linux, BSDs, MacOS and Windows.
+Inspired by [execjs-fastnode](https://github.com/jhawthorn/execjs-fastnode).
+
+### Installation
+
+In Gemfile:
+`gem 'speednode'`, then `bundle install`
+
+### Configuration
+
+Speednode provides one node based runtime `Speednode` which runs scripts in node vms.
+The runtime can be chosen by:
+
+```ruby
+ExecJS.runtime = ExecJS::Runtimes::Speednode
+```
+If node cant find node modules for the permissive contexts (see below), its possible to set the load path before assigning the runtime:
+```ruby
+ENV['NODE_PATH'] = './node_modules'
+```
+
+### Contexts
+
+Each ExecJS context runs in a node vm. Speednode offers two kinds of contexts:
+- a compatible context, which is compatible with default ExecJS behavior.
+- a permissive context, which is more permissive and allows to `require` node modules.
+
+#### Compatible
+A compatible context can be created with the standard `ExecJS.compile` or code can be executed within a compatible context by using the standard `ExecJS.eval` or `ExecJS.exec`.
+Example for a compatible context:
+```ruby
+compat_context = ExecJS.compile('Test = "test"')
+compat_context.eval('1+1')
+```
+#### Permissive
+A permissive context can be created with `ExecJS.permissive_compile` or code can be executed within a permissive context by using
+`ExecJS.permissive_eval` or `ExecJS.permissive_exec`.
+Example for a permissive context:
+```ruby
+perm_context = ExecJS.permissive_compile('Test = "test"')
+perm_context.eval('1+1')
+```
+Evaluation in a permissive context:
+```ruby
+ExecJS.permissive_eval('1+1')
+```
+
+#### Stopping Contexts
+Contexts can be stopped programmatically. If all contexts of a VM are stopped, the VM itself will be shut down with Node exiting, freeing memory and resources.
+```ruby
+context = ExecJS.compile('Test = "test"') # will start a node process
+ExecJS::Runtimes::Speednode.stop_context(context) # will kill the node process
+```
+
+### Precompiling and Storing scripts for repeated execution
+
+Scripts can be precompiled and stored for repeated execution, which leads to a significant performance improvement, especially for larger scripts:
+```ruby
+context = ExecJS.compile('Test = "test"')
+context.add_script(key: 'super', source: some_large_javascript) # will compile and store the script
+context.eval_script(key: 'super') # will run the precompiled script in the context
+```
+For the actual performance benefit see below.
+
+### Async function support
+
+Its possible to call async functions synchronously from ruby using Context#await:
+```ruby
+context = ExecJS.compile('')
+context.eval <<~JAVASCRIPT
+  async function foo(val) {
+    return new Promise(function (resolve, reject) { resolve(val); });
+  }
+JAVASCRIPT
+
+context.await("foo('test')") # => 'test'
+```
+
+### Attaching ruby methods to Permissive Contexts
+
+Ruby methods can be attached to Permissive Contexts using Context#attach:
+```ruby
+  context = ExecJS.permissive_compile(SOURCE)
+  context.attach('foo') { |v| v }
+  context.await('foo("bar")')
+```
+The attached method is reflected in the context by a async javascript function. From within javascript the ruby method is best called using await:
+```javascript
+r = await foo('test');
+```
+or via context#await as in above example.
+Attaching and calling ruby methods to/from permissive contexts is not that fast. It is recommended to use it sparingly.
+
+### Benchmarks
+
+Highly scientific, maybe.
+
+1000 rounds using speednode 0.8.0 with node 20.11.0 on a older CPU on Linux
+(ctx = using context, scsc = using precompiled scripts):
+```
+ExecJS CoffeeScript eval:            real
+Speednode Node.js (V8):          0.324355
+Speednode Node.js (V8) ctx:      0.276933
+Speednode Node.js (V8) scsc:     0.239678
+mini_racer (0.8.0):              0.204274
+mini_racer (0.8.0) ctx:          0.134327
+
+Eval overhead benchmark:             real
+Speednode Node.js (V8):          0.064198
+Speednode Node.js (V8) ctx:      0.065521
+Speednode Node.js (V8) scsc:     0.050652
+mini_racer (0.8.0):              0.010653
+mini_racer (0.8.0) ctx:          0.007764
+```
+
+To run benchmarks:
+- clone repo
+- `bundle install`
+- `bundle exec rake bench`
+
+### Tests
+
+To run tests:
+- clone repo
+- `bundle install`
+- `bundle exec rake`

data/lib/speednode/attach_pipe.rb

@@ -0,0 +1,224 @@
+require 'ffi'
+
+module Speednode
+  module WindowsyThings
+    extend FFI::Library
+
+    ffi_lib :kernel32, :user32
+
+    ERROR_IO_PENDING      = 997
+    ERROR_PIPE_CONNECTED  = 535
+    ERROR_SUCCESS         = 0
+
+    FILE_FLAG_OVERLAPPED  = 0x40000000
+
+    INFINITE              = 0xFFFFFFFF
+    INVALID_HANDLE_VALUE  = FFI::Pointer.new(-1).address
+
+    PIPE_ACCESS_DUPLEX    = 0x00000003
+    PIPE_READMODE_BYTE    = 0x00000000
+    PIPE_READMODE_MESSAGE = 0x00000002
+    PIPE_TYPE_BYTE        = 0x00000000
+    PIPE_TYPE_MESSAGE     = 0x00000004
+    PIPE_WAIT             = 0x00000000
+
+    QS_ALLINPUT           = 0x04FF
+
+    typedef :uintptr_t, :handle
+
+    attach_function :ConnectNamedPipe, [:handle, :pointer], :ulong
+    attach_function :CreateEvent, :CreateEventA, [:pointer, :ulong, :ulong, :string], :handle
+    attach_function :CreateNamedPipe, :CreateNamedPipeA, [:string, :ulong, :ulong, :ulong, :ulong, :ulong, :ulong, :pointer], :handle
+    attach_function :DisconnectNamedPipe, [:handle], :bool
+    attach_function :FlushFileBuffers, [:handle], :bool
+    attach_function :GetLastError, [], :ulong
+    attach_function :GetOverlappedResult, [:handle, :pointer, :pointer, :bool], :bool
+    attach_function :MsgWaitForMultipleObjects, [:ulong, :pointer, :ulong, :ulong, :ulong], :ulong
+    attach_function :ReadFile, [:handle, :buffer_out, :ulong, :pointer, :pointer], :bool
+    attach_function :SetEvent, [:handle], :bool
+    attach_function :WaitForMultipleObjects, [:ulong, :pointer, :ulong, :ulong], :ulong
+    attach_function :WriteFile, [:handle, :buffer_in, :ulong, :pointer, :pointer], :bool
+  end
+
+  class AttachPipe
+    include Speednode::WindowsyThings
+
+    CONNECTING_STATE = 0
+    READING_STATE    = 1
+    WRITING_STATE    = 2
+    INSTANCES        = 4
+    PIPE_TIMEOUT     = 5000
+    BUFFER_SIZE      = 65536
+
+    class Overlapped < FFI::Struct
+      layout(
+        :Internal, :uintptr_t,
+        :InternalHigh, :uintptr_t,
+        :Offset, :ulong,
+        :OffsetHigh, :ulong,
+        :hEvent, :uintptr_t
+      )
+    end
+
+    def initialize(pipe_name, block)
+      @run_block = block
+      @full_pipe_name = "\\\\.\\pipe\\#{pipe_name}"
+      @instances = 1
+      @events = []
+      @events_pointer = FFI::MemoryPointer.new(:uintptr_t, @instances + 1)
+      @pipe = {}
+    end
+
+    def run
+      @running = true
+      create_instance
+      while_loop
+    end
+
+    def stop
+      @running = false
+      warn("DisconnectNamedPipe failed with #{GetLastError()}") if !DisconnectNamedPipe(@pipe[:instance])
+    end
+
+    private
+
+    def create_instance
+      @events[0] = CreateEvent(nil, 1, 1, nil)
+      raise "CreateEvent failed with #{GetLastError()}" unless @events[0]
+
+      overlap = Overlapped.new
+      overlap[:hEvent] = @events[0]
+
+      @pipe = { overlap: overlap, instance: nil, request: FFI::Buffer.new(1, BUFFER_SIZE), bytes_read: 0, reply: FFI::Buffer.new(1, BUFFER_SIZE), bytes_to_write: 0, state: nil, pending_io: false }
+      @pipe[:instance] = CreateNamedPipe(@full_pipe_name,
+                                        PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+                                        PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+                                        4,
+                                        BUFFER_SIZE,
+                                        BUFFER_SIZE,
+                                        PIPE_TIMEOUT,
+                                        nil)
+      raise "CreateNamedPipe failed with #{GetLastError()}" if @pipe[:instance] == INVALID_HANDLE_VALUE
+      @pipe[:pending_io] = connect_to_new_client
+      @pipe[:state] = @pipe[:pending_io] ? CONNECTING_STATE : READING_STATE
+
+      @events_pointer.write_array_of_ulong_long(@events)
+      nil
+    end
+
+    def while_loop
+      while @running
+        # this sleep gives other ruby threads a chance to run
+        # ~10ms is a ruby thread time slice, so we choose something a bit larger
+        # that ruby or the os is free to switch threads
+        sleep 0.010 if @pipe[:state] != WRITING_STATE && @pipe[:state] != READING_STATE
+
+        i = MsgWaitForMultipleObjects(@instances, @events_pointer, 0, 1, QS_ALLINPUT) if @pipe[:state] != WRITING_STATE
+
+        if i > 0
+          next
+        end
+
+        if @pipe[:pending_io]
+          bytes_transferred = FFI::MemoryPointer.new(:ulong)
+          success = GetOverlappedResult(@pipe[:instance], @pipe[:overlap], bytes_transferred, false)
+
+          case @pipe[:state]
+          when CONNECTING_STATE
+            raise "Error #{GetLastError()}" unless success
+            @pipe[:state] = READING_STATE
+          when READING_STATE
+            if !success || bytes_transferred.read_ulong == 0
+              disconnect_and_reconnect(i)
+              next
+            else
+              @pipe[:bytes_read] = bytes_transferred.read_ulong
+              @pipe[:state] = WRITING_STATE
+            end
+          when WRITING_STATE
+            if !success || bytes_transferred.read_ulong != @pipe[:bytes_to_write]
+              disconnect_and_reconnect(i)
+              next
+            else
+              @pipe[:state] = READING_STATE
+            end
+          else
+            raise "Invalid pipe state."
+          end
+        end
+
+        case @pipe[:state]
+        when READING_STATE
+          bytes_read = FFI::MemoryPointer.new(:ulong)
+          success = ReadFile(@pipe[:instance], @pipe[:request], BUFFER_SIZE, bytes_read, @pipe[:overlap].to_ptr)
+          if success && bytes_read.read_ulong != 0
+            @pipe[:pending_io] = false
+            @pipe[:state] = WRITING_STATE
+            next
+          end
+
+          err = GetLastError()
+          if !success && err == ERROR_IO_PENDING
+            @pipe[:pending_io] = true
+            next
+          end
+
+          disconnect_and_reconnect
+        when WRITING_STATE
+          @pipe[:reply] = @run_block.call(@pipe[:request].get_string(0))
+          @pipe[:bytes_to_write] = @pipe[:reply].bytesize
+          bytes_written = FFI::MemoryPointer.new(:ulong)
+          success = WriteFile(@pipe[:instance], @pipe[:reply], @pipe[:bytes_to_write], bytes_written, @pipe[:overlap].to_ptr)
+
+          if success && bytes_written.read_ulong == @pipe[:bytes_to_write]
+            @pipe[:pending_io] = false
+            @pipe[:state] = READING_STATE
+            next
+          end
+
+          err = GetLastError()
+
+          if !success && err == ERROR_IO_PENDING
+            @pipe[:pending_io] = true
+            next
+          end
+
+          disconnect_and_reconnect
+        else
+          raise "Invalid pipe state."
+        end
+      end
+    end
+
+    def disconnect_and_reconnect
+      FlushFileBuffers(@pipe[:instance])
+      warn("DisconnectNamedPipe failed with #{GetLastError()}") if !DisconnectNamedPipe(@pipe[:instance])
+
+      @pipe[:pending_io] = connect_to_new_client
+
+      @pipe[:state] = @pipe[:pending_io] ? CONNECTING_STATE : READING_STATE
+    end
+
+    def connect_to_new_client
+      pending_io = false
+      @pipe[:request].clear
+      @pipe[:reply].clear
+      connected = ConnectNamedPipe(@pipe[:instance], @pipe[:overlap].to_ptr)
+      last_error = GetLastError()
+      raise "ConnectNamedPipe failed with #{last_error} - #{connected}" if connected != 0
+
+      case last_error
+      when ERROR_IO_PENDING
+        pending_io = true
+      when ERROR_PIPE_CONNECTED
+        SetEvent(@pipe[:overlap][:hEvent])
+      when ERROR_SUCCESS
+        pending_io = true
+      else
+        raise "ConnectNamedPipe failed with error #{last_error}"
+      end
+
+      pending_io
+    end
+  end
+end

data/lib/speednode/attach_socket.rb

@@ -0,0 +1,43 @@
+require 'socket'
+
+module Speednode
+  class AttachSocket
+
+    attr_reader :socket
+
+    def initialize(socket_path, block)
+      @socket_path = socket_path
+      @run_block = block
+    end
+
+    def run
+      @running = true
+      client = nil
+      ret = nil
+      @socket = UNIXServer.new(@socket_path)
+
+      while @running do
+        if ret
+          begin
+            client = @socket.accept_nonblock
+            request = client.gets("\x04")
+            result = @run_block.call(request)
+            client.write result
+            client.flush
+            client.close
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          end
+        end
+        ret = begin
+                IO.select([@socket], nil, nil, nil) || next
+              rescue Errno::EBADF
+              end
+      end
+    end
+
+    def stop
+      @running = false
+      @socket.close
+    end
+  end
+end

data/lib/speednode/config.rb

@@ -0,0 +1,23 @@
+module Speednode
+  class << self
+    attr_accessor :node_paths
+
+    def set_node_paths
+      np_sep = Gem.win_platform? ? ';' : ':'
+      existing_node_path = ENV['NODE_PATH']
+      temp_node_path = ''
+      if existing_node_path.nil? || existing_node_path.empty?
+        temp_node_path = Speednode.node_paths.join(np_sep)
+      else
+        if existing_node_path.end_with?(np_sep)
+          temp_node_path = existing_node_path + Speednode.node_paths.join(np_sep)
+        else
+          temp_node_path = existing_node_path + np_sep + Speednode.node_paths.join(np_sep)
+        end
+      end
+      ENV['NODE_PATH'] = temp_node_path.split(np_sep).uniq.join(np_sep)
+    end
+  end
+
+  self.node_paths = []
+end

data/lib/speednode/execjs_module.rb

@@ -0,0 +1,19 @@
+module ExecJS
+  class << self
+    def permissive_bench(source, options = {})
+      runtime.permissive_bench(source, options)
+    end
+
+    def permissive_exec(source, options = {})
+      runtime.permissive_exec(source, options)
+    end
+
+    def permissive_eval(source, options = {})
+      runtime.permissive_eval(source, options)
+    end
+
+    def permissive_compile(source, options = {})
+      runtime.permissive_compile(source, options)
+    end
+  end
+end

data/lib/speednode/execjs_runtime.rb

@@ -0,0 +1,23 @@
+module ExecJS
+  # Abstract base class for runtimes
+  class Runtime
+    def permissive_bench(source, options = {})
+      context = permissive_compile("", options)
+      context.bench(source, options)
+    end
+
+    def permissive_exec(source, options = {})
+      context = permissive_compile("", options)
+      context.exec(source, options)
+    end
+
+    def permissive_eval(source, options = {})
+      context = permissive_compile("", options)
+      context.eval(source, options)
+    end
+
+    def permissive_compile(source, options = {})
+      context_class.new(self, source, options.merge({permissive: true}))
+    end
+  end
+end

data/lib/speednode/execjs_runtimes.rb

@@ -0,0 +1,11 @@
+module ExecJS
+  module Runtimes
+    Speednode = Speednode::Runtime.new(
+      name: 'Speednode Node.js (V8)',
+      command: %w[node nodejs],
+      runner_path: File.join(File.dirname(__FILE__), 'runner.js'),
+      encoding: 'UTF-8'
+    )
+    runtimes.unshift(Speednode)
+  end
+end

data/lib/speednode/node_command.rb

@@ -0,0 +1,41 @@
+module Speednode
+  class NodeCommand
+    def self.which(command)
+      Array(command).find do |name|
+        name, args = name.split(/\s+/, 2)
+        path = locate_executable(name)
+
+        next unless path
+
+        args ? "#{path} #{args}" : path
+      end
+    end
+
+    def self.cached(command)
+      @cached_command ||= which(command)
+    end
+
+    private
+
+    def self.locate_executable(command)
+      commands = Array(command)
+      if ExecJS.windows? && File.extname(command) == ""
+        ENV['PATHEXT'].split(File::PATH_SEPARATOR).each { |p|
+          commands << (command + p)
+        }
+      end
+
+      commands.find { |cmd|
+        if File.executable? cmd
+          cmd
+        else
+          path = ENV['PATH'].split(File::PATH_SEPARATOR).find { |p|
+            full_path = File.join(p, cmd)
+            File.executable?(full_path) && File.file?(full_path)
+          }
+          path && File.expand_path(cmd, path)
+        end
+      }
+    end
+  end
+end