isomorfeus-speednode 0.3.1 → 0.4.3

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 = 50
+
+          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