isomorfeus-speednode 0.2.11 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 917120184f53418bf061f3fbb7020f9ebbfd33ddc24475f06544aca2b8787b2a
-  data.tar.gz: 9c1e6cdc8c62dbf4db3d1bb27bad4b392ff520de3ca2c76586eec3ce9c43bb50
+  metadata.gz: 1bb65853d666ae62943ed28b887dc6792c83c34bd7ed090d7bc817a42e40c63e
+  data.tar.gz: '0227178ecf8760e07f32043beba064258da9efa6baa221c96b0437ee12a6fc80'
 SHA512:
-  metadata.gz: 4e6d3aa1bc6654ac85c39681fb71ce699174fa6c65366a91732fff9d3a8f3f2fef6c967f080e17e94b3af1215764d2d978e23666ffa44521a01d100d42d1c6e3
-  data.tar.gz: db5a4fcab7ce656f507f1674e397c9a084867b24353c4ffabe294c33694234c86a85d5b9e737d9f8b88a373daa059b0a30e03f5cd5ece4e8a4c52d51a702280b
+  metadata.gz: ee26a18eb0e0209f543ce01cf240824edd3d00c8590a57c72a0422680c48127318a4111f7417f424b48ae8ffbc72b43c3bac7c03da8ee62baa265a49880471e8
+  data.tar.gz: a9da737b51f2b115bac2c218d2abc0618b443daa2cc2cd380991a30b4b4a998cb6c2497356d30279f04e717c86cf61a557173506b19859b711ca895a10880d75

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016 John Hawthorn
+Copyright (c) 2019 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

@@ -1,83 +1,127 @@
-# isomorfeus-speednode
-
-A fast runtime for execjs using node js.
-Inspired by [execjs-fastnode](https://github.com/jhawthorn/execjs-fastnode).
-
-### Community and Support
-At the [Isomorfeus Framework Project](http://isomorfeus.com) 
-
-### Tested
-[TravisCI](https://travis-ci.org): [![Build Status](https://travis-ci.org/isomorfeus/isomorfeus-speednode.svg?branch=master)](https://travis-ci.org/isomorfeus/isomorfeus-speednode)
-
-### Installation
-
-In Gemfile:
-`gem 'isomorfeus-speednode'`, then `bundle install`
-
-### Configuration
-
-Isomorfeus-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')
-```
-
-### Benchmarks
-
-Highly scientific, maybe.
-```
-standard ExecJS CoffeeScript call benchmark, but 1000 rounds:
-                                                   user     system      total        real
-Isomorfeus Speednode Compatible Node.js (V8)   0.042263   0.017215   0.059478 (  0.442855)
-Node.js (V8) fast                              0.222875   0.087109   0.309984 (  0.806736)
-mini_racer (V8)                                0.425273   0.013478   0.438751 (  0.304434)
-
-
-call overhead benchmark, 1000 rounds:
-                                                   user     system      total        real
-Isomorfeus Speednode Compatible Node.js (V8)   0.023060   0.010358   0.033418 (  0.059640)
-Node.js (V8) fast                              0.191454   0.081396   0.272850 (  0.368568)
-mini_racer (V8)                                0.017091   0.002494   0.019585 (  0.019584)
-```
-
-To run benchmarks:
-- clone repo
-- `bundle install`
-- `bundle exec rake bench`
-
-### Tests
-To run tests:
-- clone repo
-- `bundle install`
+# isomorfeus-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).
+
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
+
+### Tested
+[TravisCI](https://travis-ci.org): [![Build Status](https://travis-ci.org/isomorfeus/isomorfeus-speednode.svg?branch=master)](https://travis-ci.org/isomorfeus/isomorfeus-speednode)
+
+### Installation
+
+In Gemfile:
+`gem 'isomorfeus-speednode'`, then `bundle install`
+
+### Configuration
+
+Isomorfeus-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')
+```
+
+### 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 node 16.6.2.:
+```
+standard ExecJS CoffeeScript eval benchmark:
+                                          user     system      total        real
+Isomorfeus Speednode Node.js (V8) Windows 0.079000   0.031000   0.110000 (  0.518821)
+Isomorfeus Speednode Node.js (V8) Linux   0.092049   0.039669   0.131718 (  0.546846)
+mini_racer (V8) 0.4.0 Linux only          0.776317   0.062923   0.839240 (  0.480490)
+Node.js (V8) Linux                        0.330156   0.354536  52.523972 ( 51.203355)
+
+evel overhead benchmark:
+                                          user     system      total        real
+Isomorfeus Speednode Node.js (V8) Windows 0.032000   0.031000   0.063000 (  0.227634)
+Isomorfeus Speednode Node.js (V8) Linux   0.085135   0.022002   0.107137 (  0.153055)
+mini_racer (V8) 0.4.0 Linux only          0.083562   0.115612   0.199174 (  0.128455)
+Node.js (V8) Linux                        0.273238   0.265101  30.169976 ( 29.636668)
+```
+minify discourse benchmark from mini_racer:
+```
+minify discourse_app_minified.js:
+                              user     system      total        real
+isomorfeus-speednode Windows  0.016000   0.078000   0.094000 ( 11.828518)
+isomorfeus-speednode Linux    0.043747   0.000000  15.931284 ( 11.860528)
+mini_racer                    0.043471   0.000000  15.974214 ( 11.923735)
+node                          0.043695   0.000000  15.812040 ( 11.781835)
+```
+
+To run benchmarks:
+- clone repo
+- `cd ruby`
+- `bundle install`
+- `bundle exec rake bench`
+
+### Tests
+
+To run tests:
+- clone repo
+- `cd ruby`
+- `bundle install`
 - `bundle exec rake test`

data/lib/isomorfeus/speednode/attach_pipe.rb

@@ -0,0 +1,226 @@
+require 'ffi'
+
+module Isomorfeus
+  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 Isomorfeus::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
+        STDERR.puts("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])
+        STDERR.puts("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
+end