speednode 0.8.1

data/lib/speednode/runtime/vm.rb

@@ -0,0 +1,223 @@
+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 Speednode
+  class Runtime < ExecJS::Runtime
+    class VM
+      def self.finalize(socket, socket_dir, socket_path, pid)
+        proc do
+          ::Speednode::Runtime.responders[socket_path].kill if ::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 rescue nil
+        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
+
+      attr_reader :responder
+
+      def initialize(options)
+        @mutex = ::Thread::Mutex.new
+        @socket_path = nil
+        @options = options
+        @started = false
+        @socket = nil
+      end
+
+      def started?
+        @started
+      end
+
+      def evsc(context, key)
+        command('evsc', { 'context' => context, 'key' => key })
+      end
+
+      def scsc(context, key, source)
+        command('scsc', { 'context' => context, 'key' => key, 'source' => source })
+      end
+
+      def eval(context, source)
+        command('eval', {'context' => context, 'source' => source})
+      end
+
+      def exec(context, source)
+        command('exec', {'context' => context, 'source' => source})
+      end
+
+      def bench(context, source)
+        command('bench', {'context' => context, 'source' => source})
+      end
+
+      def create(context, source, options)
+        command('create', {'context' => context, 'source' => source, 'options' => options})
+      end
+
+      def created(context, source, options)
+        command('created', {'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)
+        @mutex.synchronize do
+          VMCommand.new(@socket, "deleteContext", context).execute rescue nil
+        end
+      rescue ThreadError
+        nil
+      end
+
+      # def context_options(context)
+      #   command('ctxo', {'context' => context })
+      # end
+
+      def start
+        @mutex.synchronize do
+          start_without_synchronization
+        end
+      end
+
+      def stop
+        return unless @started
+        @mutex.synchronize do
+          self.class.exit_node(@socket, @socket_dir, @socket_path, @pid)
+          @socket_path = nil
+          @started = false
+          @socket = nil
+        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("iso-speednode-")
+          @socket_path = File.join(@socket_dir, "socket")
+        end
+        @pid = Process.spawn({"SOCKET_PATH" => @socket_path}, @options[:binary], '--expose-gc', @options[:source_maps], @options[:runner_path])
+
+        retries = 500
+
+        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
+
+        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 = ::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?
+                                    ::Speednode::AttachPipe.new(responder_path, run_block).run
+                                  else
+                                    ::Speednode::AttachSocket.new(responder_path, run_block).run
+                                  end
+                                end
+        ::Speednode::Runtime.responders[@socket_path] = @responder_thread
+        @responder.run
+      end
+
+      def command(cmd, argument)
+        @mutex.synchronize do
+          start_without_synchronization unless @started
+          VMCommand.new(@socket, cmd, argument).execute
+        end
+      end
+    end
+  end
+end

data/lib/speednode/runtime/vm_command.rb

@@ -0,0 +1,38 @@
+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!, mode: :strict)
+      end
+    end
+  end
+end

data/lib/speednode/runtime.rb

@@ -0,0 +1,55 @@
+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      = ::Speednode::NodeCommand.cached(options[:command])
+      @runner_path = options[:runner_path]
+      @vm = VM.new(binary: @binary, source_maps: '--enable-source-maps', runner_path: @runner_path)
+      @encoding    = options[:encoding]
+      @deprecated  = !!options[:deprecated]
+      @popen_options = {}
+      @popen_options[:external_encoding] = @encoding if @encoding
+      @popen_options[:internal_encoding] = ::Encoding.default_internal || 'UTF-8'
+      @contexts = {} 
+    end
+
+    def register_context(uuid, context)
+      @contexts[uuid] = context
+    end
+
+    def unregister_context(uuid)
+      context = @contexts.delete(uuid)
+      if context && @vm
+        ObjectSpace.undefine_finalizer(context)
+        @vm.delete_context(uuid) rescue nil # if delete_context fails, the vm exited before probably
+      end
+      @vm.stop if @contexts.size == 0 && @vm.started?
+    end
+
+    def stop_context(context)
+      unregister_context(context.instance_variable_get(:@uuid))
+    end
+
+    def available?
+      @binary ? true : false
+    end
+
+    def deprecated?
+      @deprecated
+    end
+  end
+end

data/lib/speednode/version.rb

@@ -0,0 +1,3 @@
+module Speednode
+  VERSION = '0.8.1'
+end

data/lib/speednode.rb

@@ -0,0 +1,21 @@
+require 'securerandom'
+require 'socket'
+require 'oj'
+require 'execjs/module'
+require 'speednode/config'
+require 'speednode/node_command'
+require 'execjs/runtime'
+if Gem.win_platform?
+  require 'speednode/attach_pipe'
+else
+  require 'speednode/attach_socket'
+end
+require 'speednode/runtime/vm'
+require 'speednode/runtime/vm_command'
+require 'speednode/runtime/context'
+require 'speednode/runtime'
+require 'execjs/runtimes'
+require 'speednode/execjs_runtime'
+require 'speednode/execjs_module'
+require 'speednode/execjs_runtimes'
+require 'execjs'

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: speednode
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.1
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.13.23
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.13.23
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.17.0
+- !ruby/object:Gem::Dependency
+  name: win32-pipe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.20.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.20.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.1.0
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A fast ExecJS runtime based on nodejs. As fast as mini_racer, but without
+  the need to compile the js engine, because it uses the system provided nodejs.
+email: jan@kursator.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/speednode.rb
+- lib/speednode/attach_pipe.rb
+- lib/speednode/attach_socket.rb
+- lib/speednode/config.rb
+- lib/speednode/execjs_module.rb
+- lib/speednode/execjs_runtime.rb
+- lib/speednode/execjs_runtimes.rb
+- lib/speednode/node_command.rb
+- lib/speednode/runner.js
+- lib/speednode/runtime.rb
+- lib/speednode/runtime/context.rb
+- lib/speednode/runtime/vm.rb
+- lib/speednode/runtime/vm_command.rb
+- lib/speednode/version.rb
+homepage: https://github.com/janbiedermann/speednode
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: A fast ExecJS runtime based on nodejs.
+test_files: []