isomorfeus-speednode 0.2.12 → 0.4.2

data/lib/isomorfeus/speednode/runtime/context.rb

@@ -0,0 +1,176 @@
+module Isomorfeus
+  module Speednode
+    class Runtime < ExecJS::Runtime
+      class Context < ::ExecJS::Runtime::Context
+        def self.finalize(runtime, uuid)
+          proc { runtime.vm.delete_context(uuid) }
+        end
+
+        def initialize(runtime, source = "", options = {})
+
+          @runtime = runtime
+          @uuid = SecureRandom.uuid
+          @permissive = !!options.delete(:permissive)
+          @vm = @runtime.vm
+          @context = nil
+          @timeout = options[:timeout] ? options[:timeout]/1000 : 600
+
+          ObjectSpace.define_finalizer(self, self.class.finalize(@runtime, @uuid))
+
+          filename = options.delete(:filename)
+          source = File.read(filename) if filename
+
+          begin
+            source = encode(source)
+          rescue
+            source = source.force_encoding('UTF-8')
+          end
+
+          @permissive ? raw_createp(source, options) : raw_create(source, options)
+        end
+
+        # def options
+        #   @vm.context_options(@uuid)
+        # end
+
+        def attach(func, procedure = nil, &block)
+          raise "#attach requires a permissive context." unless @permissive
+          run_block = block_given? ? block : procedure
+          Isomorfeus::Speednode::Runtime.attach_proc(@uuid, func, run_block)
+          @vm.attach(@uuid, func)
+        end
+
+        def await(source)
+          raw_eval <<~JAVASCRIPT
+            (async () => {
+              global.__LastExecutionFinished = false;
+              global.__LastResult = null;
+              global.__LastErr = null;
+              global.__LastResult = await #{source};
+              global.__LastExecutionFinished = true;
+            })().catch(function(err) {
+              global.__LastResult = null;
+              global.__LastErr = err;
+              global.__LastExecutionFinished = true;
+            })
+          JAVASCRIPT
+          await_result
+        end
+
+        def call(identifier, *args)
+          raw_eval("#{identifier}.apply(this, #{::Oj.dump(args, mode: :strict)})")
+        end
+
+        def eval(source, _options = nil)
+          raw_eval(source) if /\S/ =~ source
+        end
+
+        def exec(source, _options = nil)
+          raw_exec("(function(){#{source}})()")
+        end
+
+        def permissive?
+          @permissive
+        end
+
+        def permissive_eval(source, _options = nil)
+          raise "Context not permissive!" unless @permissive
+          raw_eval(source) if /\S/ =~ source
+        end
+
+        def permissive_exec(source, _options = nil)
+          raise "Context not permissive!" unless @permissive
+          raw_exec("(function(){#{source}})()")
+        end
+
+        protected
+
+        def raw_eval(source)
+          extract_result(@vm.eval(@uuid, encode(source)))
+        end
+
+
+        def raw_exec(source)
+          extract_result(@vm.exec(@uuid, encode(source)))
+        end
+
+        def raw_create(source, options)
+          return if @context
+          source = encode(source)
+          result = @vm.create(@uuid, source, options)
+          @context = true
+          extract_result(result)
+        end
+
+        def raw_createp(source, options)
+          return if @context
+          source = encode(source)
+          result = @vm.createp(@uuid, source, options)
+          @context = true
+          extract_result(result)
+        end
+
+        def extract_result(output) 
+          if output[0] == 'ok'
+            output[1]
+          else
+            _status, value, stack = output
+            stack ||= ""
+            stack = stack.split("\n").map do |line|
+              line.sub(" at ", "").strip
+            end
+            stack.reject! do |line|
+              line.include?('(node:') ||
+              line.include?('lib\isomorfeus\speednode\runner.js') ||
+              line.include?('lib/isomorfeus/speednode/runner.js')
+            end
+            stack.shift unless stack[0].to_s.include?("(execjs)")
+            error_class = value =~ /SyntaxError:/ ? ExecJS::RuntimeError : ExecJS::ProgramError
+            error = error_class.new(value)
+            error.set_backtrace(stack + caller)
+            raise error
+          end
+        end
+
+        def await_result
+          start_time = Time.now
+          while !execution_finished? && !timed_out?(start_time)
+            sleep 0.005
+          end
+          result = exec <<~JAVASCRIPT
+            if (global.__LastExecutionFinished === true) {
+              var err = global.__LastErr;
+              var result = global.__LastResult;
+
+              global.__LastErr = null;
+              global.__LastResult = null;
+              global.__LastExecutionFinished = false;
+
+              if (err) { return ['err', ['', err].join(''), err.stack]; }
+              else if (typeof result === 'undefined' && result !== null) { return ['ok']; }
+              else {
+                  try { return ['ok', result]; }
+                  catch (err) { return ['err', ['', err].join(''), err.stack]; }
+              }
+            } else {
+              var new_err = new Error('Last command did not yet finish execution!');
+              return ['err', ['', new_err].join(''), new_err.stack];
+            }
+          JAVASCRIPT
+          extract_result(result)
+        end
+
+        def execution_finished?
+          eval 'global.__LastExecutionFinished'
+        end
+
+        def timed_out?(start_time)
+          if (Time.now - start_time) > @timeout
+            raise "Command Execution timed out!"
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/speednode/runtime/vm.rb

@@ -0,0 +1,204 @@
+if Gem.win_platform?
+  require 'securerandom'
+  require 'win32/pipe'
+
+  module Win32
+    class Pipe
+      def write(data)
+        bytes = FFI::MemoryPointer.new(:ulong)
+
+        raise Error, "no pipe created" unless @pipe
+
+        if @asynchronous
+          bool = WriteFile(@pipe, data, data.bytesize, bytes, @overlapped)
+          bytes_written = bytes.read_ulong
+
+          if bool && bytes_written > 0
+            @pending_io = false
+            return true
+          end
+
+          error = GetLastError()
+          if !bool && error == ERROR_IO_PENDING
+            @pending_io = true
+            return true
+          end
+
+          return false
+        else
+          unless WriteFile(@pipe, data, data.bytesize, bytes, nil)
+            raise SystemCallError.new("WriteFile", FFI.errno)
+          end
+
+          return true
+        end
+      end
+    end
+  end
+end
+
+module Isomorfeus
+  module Speednode
+    class Runtime < ExecJS::Runtime
+      class VM
+        attr_reader :responder
+
+        def initialize(options)
+          @mutex = Mutex.new
+          @socket_path = nil
+          @options = options
+          @started = false
+          @socket = nil
+        end
+
+        def started?
+          @started
+        end
+
+        def self.finalize(socket, socket_dir, socket_path, pid)
+          proc do 
+            Isomorfeus::Speednode::Runtime.responders[socket_path].kill if Isomorfeus::Speednode::Runtime.responders[socket_path]
+            exit_node(socket, socket_dir, socket_path, pid)
+          end
+        end
+
+        def self.exit_node(socket, socket_dir, socket_path, pid)
+          VMCommand.new(socket, "exit", [0]).execute
+          socket.close
+          File.unlink(socket_path) if File.exist?(socket_path)
+          Dir.rmdir(socket_dir) if socket_dir && Dir.exist?(socket_dir)
+          if Gem.win_platform?
+            # SIGINT or SIGKILL are unreliable on Windows, try native taskkill first
+            unless system("taskkill /f /t /pid #{pid} >NUL 2>NUL")
+              Process.kill('KILL', pid) rescue nil
+            end
+          else
+            Process.kill('KILL', pid) rescue nil
+          end
+        rescue
+          nil
+        end
+
+        def eval(context, source)
+          command("eval", {'context' => context, 'source' => source})
+        end
+
+        def exec(context, source)
+          command("exec", {'context' => context, 'source' => source})
+        end
+
+        def create(context, source, options)
+          command("create", {'context' => context, 'source' => source, 'options' => options})
+        end
+
+        def createp(context, source, options)
+          command("createp", {'context' => context, 'source' => source, 'options' => options})
+        end
+
+        def attach(context, func)
+          create_responder(context) unless responder
+          command("attach", {'context' => context, 'func' => func }) 
+        end
+
+        def delete_context(context)
+          command("deleteContext", context)
+        end
+
+        # def context_options(context)
+        #   command('ctxo', {'context' => context })
+        # end
+
+        def start
+          @mutex.synchronize do
+            start_without_synchronization
+          end
+        end
+
+        private
+
+        def start_without_synchronization
+          return if @started
+          if ExecJS.windows?
+            @socket_dir = nil
+            @socket_path = SecureRandom.uuid
+          else
+            @socket_dir = Dir.mktmpdir("isomorfeus-speednode-")
+            @socket_path = File.join(@socket_dir, "socket")
+          end
+          @pid = Process.spawn({"SOCKET_PATH" => @socket_path}, @options[:binary], @options[:source_maps], @options[:runner_path])
+
+          retries = 20
+
+          if ExecJS.windows?
+            timeout_or_connected = false
+            begin
+              retries -= 1 
+              begin
+                @socket = Win32::Pipe::Client.new(@socket_path, Win32::Pipe::ACCESS_DUPLEX)
+              rescue
+                sleep 0.1
+                raise "Unable to start nodejs process in time" if retries == 0
+                next
+              end
+              timeout_or_connected = true
+            end until timeout_or_connected
+          else
+            while !File.exist?(@socket_path)
+              sleep 0.1
+              retries -= 1
+              raise "Unable to start nodejs process in time" if retries == 0
+            end
+
+            @socket = UNIXSocket.new(@socket_path)
+          end
+
+          @started = true
+
+          at_exit do
+            begin
+              self.class.exit_node(@socket, @socket_dir, @socket_path, @pid) unless @socket.closed?
+            rescue
+              # do nothing
+            end
+          end
+
+          ObjectSpace.define_finalizer(self, self.class.finalize(@socket, @socket_dir, @socket_path, @pid))
+          Kernel.at_exit { self.class.finalize(@socket, @socket_dir, @socket_path, @pid).call }
+        end
+
+        def create_responder(context)
+          start unless @started
+          run_block = Proc.new do |request|
+            args = ::Oj.load(request.chop!, mode: :strict)
+            req_context = args[0]
+            method = args[1]
+            method_args = args[2]
+            begin
+              result = Isomorfeus::Speednode::Runtime.attached_procs[req_context][method].call(*method_args)
+              ::Oj.dump(['ok', result], mode: :strict)
+            rescue Exception => err
+              ::Oj.dump(['err', err.class.to_s, [err.message].concat(err.backtrace)], mode: :strict)
+            end
+          end
+          responder_path = @socket_path + '_responder'
+          @responder = Thread.new do
+                                    if ExecJS.windows?
+                                      Isomorfeus::Speednode::AttachPipe.new(responder_path, run_block).run
+                                    else
+                                      Isomorfeus::Speednode::AttachSocket.new(responder_path, run_block).run
+                                    end
+                                  end
+          Isomorfeus::Speednode::Runtime.responders[@socket_path] = @responder_thread
+          @responder.run
+        end
+
+        def command(cmd, *arguments)
+          @mutex.synchronize do
+            start_without_synchronization unless @started
+            VMCommand.new(@socket, cmd, arguments).execute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/speednode/runtime/vm_command.rb

@@ -0,0 +1,40 @@
+module Isomorfeus
+  module Speednode
+    class Runtime < ExecJS::Runtime
+      class VMCommand
+        def initialize(socket, cmd, arguments)
+          @socket = socket
+          @cmd = cmd
+          @arguments = arguments
+        end
+
+        def execute
+          result = ''
+          message = ::Oj.dump({ 'cmd' => @cmd, 'args' => @arguments }, mode: :strict)
+          message = message + "\x04"
+          bytes_to_send = message.bytesize
+          sent_bytes = 0
+
+          if ExecJS.windows?
+            @socket.write(message)
+            begin
+              result << @socket.read
+            end until result.end_with?("\x04")
+          else
+            sent_bytes = @socket.sendmsg(message)
+            if sent_bytes < bytes_to_send
+              while sent_bytes < bytes_to_send
+                sent_bytes += @socket.sendmsg(message.byteslice((sent_bytes)..-1))
+              end
+            end
+            
+            begin
+              result << @socket.recvmsg()[0]
+            end until result.end_with?("\x04")
+          end
+          ::Oj.load(result.chop!, create_additions: false)
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/speednode/runtime.rb

@@ -1,213 +1,45 @@
-module Isomorfeus
-  module Speednode
-    class Runtime < ExecJS::Runtime
-      class VMCommand
-        def initialize(socket, cmd, arguments)
-          @socket = socket
-          @cmd = cmd
-          @arguments = arguments
-        end
-
-        def execute
-          result = ''
-          message = ::Oj.dump({ 'cmd' => @cmd, 'args' => @arguments }, mode: :strict)
-          @socket.sendmsg(message + "\x04")
-          begin
-            result << @socket.recvmsg()[0]
-          end until result.end_with?("\x04")
-          ::Oj.load(result.chop!, create_additions: false)
-        end
-      end
-
-      class VM
-        def initialize(options)
-          @mutex = Mutex.new
-          @socket_path = nil
-          @options = options
-          @started = false
-          @socket = nil
-        end
-
-        def started?
-          @started
-        end
-
-        def self.finalize(socket, socket_dir, socket_path, pid)
-          proc { exit_node(socket, socket_dir, socket_path, pid) }
-        end
-
-        def self.exit_node(socket, socket_dir, socket_path, pid)
-          VMCommand.new(socket, "exit", [0]).execute
-          socket.close
-          File.unlink(socket_path)
-          Dir.rmdir(socket_dir)
-          Process.kill('KILL', pid)
-        end
-
-        def exec(context, source)
-          command("exec", {'context' => context, 'source' => source})
-        end
-
-        def execp(context, source)
-          command("execp", {'context' => context, 'source' => source})
-        end
-
-        def delete_context(context)
-          command("deleteContext", context)
-        end
-
-        def start
-          @mutex.synchronize do
-            start_without_synchronization
-          end
-        end
-
-        private
-
-        def start_without_synchronization
-          return if @started
-          @socket_dir = Dir.mktmpdir("isomorfeus-speednode-")
-          @socket_path = File.join(@socket_dir, "socket")
-          @pid = Process.spawn({"SOCKET_PATH" => @socket_path}, @options[:binary], @options[:runner_path])
-
-          retries = 20
-          while !File.exist?(@socket_path)
-            sleep 0.05
-            retries -= 1
-
-            if retries == 0
-              raise "Unable to start nodejs process in time"
-            end
-          end
-
-          @socket = UNIXSocket.new(@socket_path)
-          @started = true
-
-          at_exit do
-            begin
-              self.class.exit_node(@socket, @socket_dir, @socket_path, @pid) unless @socket.closed?
-            rescue
-              # do nothing
-            end
-          end
-
-          ObjectSpace.define_finalizer(self, self.class.finalize(@socket, @socket_dir, @socket_path, @pid))
-        end
-
-        def command(cmd, *arguments)
-          @mutex.synchronize do
-            start_without_synchronization
-            VMCommand.new(@socket, cmd, arguments).execute
-          end
-        end
-      end
-
-      class Context < ::ExecJS::Runtime::Context
-        def initialize(runtime, source = "", options = {})
-          @runtime = runtime
-          @uuid = SecureRandom.uuid
-          @permissive = !!options[:permissive]
-
-          ObjectSpace.define_finalizer(self, self.class.finalize(@runtime, @uuid))
-
-          begin
-            source = encode(source)
-          rescue
-            source = source.force_encoding('UTF-8')
-          end
-
-          @permissive ? raw_execp(source) : raw_exec(source)
-        end
-
-        def self.finalize(runtime, uuid)
-          proc { runtime.vm.delete_context(uuid) }
-        end
-
-        def call(identifier, *args)
-          eval "#{identifier}.apply(this, #{::Oj.dump(args, mode: :strict)})"
-        end
-
-        def eval(source, options = {})
-          raw_exec("(#{source})") if /\S/ =~ source
-        end
-
-        def exec(source, options = {})
-          raw_exec("(function(){#{source}})()")
-        end
-
-        def permissive?
-          @permissive
-        end
-
-        def permissive_eval(source, options = {})
-          raw_execp("(#{source})") if /\S/ =~ source
-        end
-
-        def permissive_exec(source, options = {})
-          raw_execp("(function(){#{source}})()")
-        end
-
-        def raw_exec(source)
-          source = encode(source)
-
-          result = @runtime.vm.exec(@uuid, source)
-          extract_result(result)
-        end
-
-        def raw_execp(source)
-          source = encode(source)
-
-          result = @runtime.vm.execp(@uuid, source)
-          extract_result(result)
-        end
-
-        protected
-
-        def extract_result(output)
-          status, value, stack = output
-          if status == "ok"
-            value
-          else
-            stack ||= ""
-            stack = stack.split("\n").map do |line|
-              line.sub(" at ", "").strip
-            end
-            stack.reject! { |line| ["eval code", "eval@[native code]"].include?(line) }
-            stack.shift unless stack[0].to_s.include?("(execjs)")
-            error_class = value =~ /SyntaxError:/ ? ExecJS::RuntimeError : ExecJS::ProgramError
-            error = error_class.new(value)
-            error.set_backtrace(stack + caller)
-            raise error
-          end
-        end
-      end
-
-      attr_reader :name, :vm
-
-      def initialize(options)
-        @name        = options[:name]
-        @binary      = Isomorfeus::Speednode::NodeCommand.cached(options[:command])
-        @runner_path = options[:runner_path]
-        @encoding    = options[:encoding]
-        @deprecated  = !!options[:deprecated]
-
-        @vm = VM.new(
-          binary: @binary,
-          runner_path: @runner_path
-        )
-
-        @popen_options = {}
-        @popen_options[:external_encoding] = @encoding if @encoding
-        @popen_options[:internal_encoding] = ::Encoding.default_internal || 'UTF-8'
-      end
-
-      def available?
-        @binary ? true : false
-      end
-
-      def deprecated?
-        @deprecated
-      end
-    end
-  end
-end
+module Isomorfeus
+  module Speednode
+    class Runtime < ExecJS::Runtime
+      def self.attach_proc(context_id, func, run_block)
+        attached_procs[context_id] = { func => run_block }
+      end
+
+      def self.attached_procs
+        @attached_procs ||= {}
+      end
+
+      def self.responders
+        @responders ||= {}
+      end
+
+      attr_reader :name, :vm
+
+      def initialize(options)
+        @name        = options[:name]
+        @binary      = Isomorfeus::Speednode::NodeCommand.cached(options[:command])
+        @runner_path = options[:runner_path]
+        @encoding    = options[:encoding]
+        @deprecated  = !!options[:deprecated]
+
+        @vm = VM.new(
+          binary: @binary,
+          source_maps: '--enable-source-maps',
+          runner_path: @runner_path
+        )
+
+        @popen_options = {}
+        @popen_options[:external_encoding] = @encoding if @encoding
+        @popen_options[:internal_encoding] = ::Encoding.default_internal || 'UTF-8'
+      end
+
+      def available?
+        @binary ? true : false
+      end
+
+      def deprecated?
+        @deprecated
+      end
+    end
+  end
+end