isomorfeus-speednode 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e0315df4f6d4730a62a4189ef7f12fcaf01e187d323ca999aa27cd0254ee7ea
-  data.tar.gz: '0711819b4c9280ff1dace7f9f7432f961383bb82cf543a0b3981d01e1a83b2be'
+  metadata.gz: 9ae800090e3226f94d53570baf613f33123e4f95bbb3e384b33d373a17328b60
+  data.tar.gz: 3036d03ea6149df04d5cb53c6d2058893e6d2a61a2ea96f0a24c1d3b694705a0
 SHA512:
-  metadata.gz: 706dded2560521f21e3e130cfa266bb725f9891b88cca7331ad5f33e3ea054186a3832a4d6aa7144428085b77bfb1fcd1a4ce09b3fd2dcfc7872e3930b3c974b
-  data.tar.gz: '018b37989b54160cdb3e89ece63dd6feb9a423dd845229472e5d5b75864487d86c0fbcd46369d0ec70e8521afa7ae0f7b91d909344475d3e8b5cb2c8b4692b0b'
+  metadata.gz: 13ccaa36e365de0b48dbc5124f8f4ff3ef123ca2177d745c895828aa5037c2d6dba1510803cb2434358117ddd3824c854bc3a44df72c5ca684176077f109c3c8
+  data.tar.gz: e66f98d834d55218c99744b66bde19a680506fd543093e1a0316234480aa46c880262cf33f16cc3722df6a31255c4f8059f4914e4ce40d9485de4233d7aeb282

data/LICENSE

@@ -1,22 +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.
+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,99 +1,127 @@
-# 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')
-```
-
-### Benchmarks
-
-Highly scientific, maybe.
-
-1000 rounds on Linux using node 16.1.0:
-```
-standard ExecJS CoffeeScript call benchmark:
-                                        user     system      total        real
-Node.js (V8) fast                   0.234199   0.093775   0.327974 (  0.877142)
-Isomorfeus Speednode Node.js (V8)   0.108882   0.048014   0.156896 (  0.587261)
-mini_racer (V8)                     0.801764   0.105020   0.906784 (  0.515463)
-Node.js (V8)                        0.420842   0.293893  52.471348 ( 50.990930)
-
-call overhead benchmark:
-                                        user     system      total        real
-Node.js (V8) fast                   0.192230   0.086253   0.278483 (  0.372702)
-Isomorfeus Speednode Node.js (V8)   0.101266   0.034985   0.136251 (  0.214831)
-mini_racer (V8)                     0.163080   0.052209   0.215289 (  0.141151)
-Node.js (V8)                        0.354932   0.218117  29.016030 ( 28.410343)
-```
-
-1000 rounds on Windows 10 using node 16.1.0:
-```
-standard ExecJS CoffeeScript call benchmark:
-                                        user     system      total        real
-Isomorfeus Speednode Node.js (V8)   0.031000   0.016000   0.047000 (  0.548920)
-Node.js (V8)                        1.172000   2.594000   3.766000 ( 91.619422)
-
-call overhead benchmark:
-                                        user     system      total        real
-Isomorfeus Speednode Node.js (V8)   0.063000   0.000000   0.063000 (  0.162426)
-Node.js (V8)                        0.656000   2.516000   3.172000 ( 63.766556)
-```
-
-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