nodo 1.5.1 → 1.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2a8ef54e67cf745b78353e740a440edf45ee300e97d50d7e0edd93abf33bf62
-  data.tar.gz: 4c5196d63edf85242640050487a86b582fb2fe9d373b79408750973b88622a68
+  metadata.gz: 650d220075d68a34268a03f2e68587b1caab13f47707c8b44f7cb7d05f5a5588
+  data.tar.gz: 0b73f0cd827a1ab364975d3559f64f2d9c49afe265759715f92d23f133bab10c
 SHA512:
-  metadata.gz: aad587338156426fd70ba262b01086056e70730aeff6774e70272c01898c9ba81e2937121226304dc00cd38f83917a788da5507160577747829a595a03a37e13
-  data.tar.gz: 14abb31d37eb578bba1233afa22c6f1d5c79ea28d9cb48eefa052604a3d148494f58c7af019b6ec85682348d357fdef79d14fea2e4d90cb30de96a6222b5935f
+  metadata.gz: 0c1049cd1e574c0a7ec503ef01ae735d7b3ca33d21695a1a76c4c8f5c92f0914db58b59136a7ea0bcf17b83f9c6776817b8b4890061e6c442e414c5476d80037
+  data.tar.gz: d5fd39f74f9ebfabaec0463dbf7234e6da34a73b3167f2580fb6ac276f52f6aef433156ef0917b4a5c9c344f1dfc6d0f28e7c1af1bfe329829c5c87068d932dd

data/README.md

@@ -1,4 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/nodo.svg)](http://badge.fury.io/rb/nodo)
+[![Gem Version](https://badge.fury.io/rb/nodo.svg)](http://badge.fury.io/rb/nodo)  [![build](https://github.com/mtgrosser/nodo/actions/workflows/build.yml/badge.svg)](https://github.com/mtgrosser/nodo/actions/workflows/build.yml)
 
 # Nōdo – call Node.js from Ruby
 
@@ -39,13 +39,13 @@ In Nodo, you define JS functions as you would define Ruby methods:
 
 ```ruby
 class Foo < Nodo::Core
-  
+
   function :say_hi, <<~JS
     (name) => {
       return `Hello ${name}!`;
     }
   JS
-  
+
 end
 
 foo = Foo.new
@@ -61,7 +61,7 @@ Install your modules to `node_modules`:
 $ yarn add uuid
 ```
 
-Then `require` your dependencies:
+`require`ing your dependencies will make the library available as a `const` with the same name:
 
 ```ruby
 class Bar < Nodo::Core
@@ -78,14 +78,26 @@ bar = Bar.new
 bar.v4 => "b305f5c4-db9a-4504-b0c3-4e097a5ec8b9"
 ```
 
+
 ### Aliasing requires
 
+If the library name cannot be used as name of the constant, the `const` name
+can be given using hash syntax:
+
 ```ruby
 class FooBar < Nodo::Core
   require commonjs: '@rollup/plugin-commonjs'
 end
 ```
 
+### Alternate function definition syntax
+
+JS code can also be supplied using the `code:` keyword argument:
+
+```ruby
+function :hello, code: "() => 'world'"
+```
+
 ### Setting NODE_PATH
 
 By default, `./node_modules` is used as the `NODE_PATH`.
@@ -126,7 +138,8 @@ end
 
 ### Inheritance
 
-Subclasses will inherit functions, constants, dependencies and scripts from their superclasses, while only functions can be overwritten.
+Subclasses will inherit functions, constants, dependencies and scripts from
+their superclasses, while only functions can be overwritten.
 
 ```ruby
 class Foo < Nodo::Core
@@ -149,7 +162,8 @@ SubSubFoo.new.bar => "callingsubsubclass"
 ### Async functions
 
 `Nodo` supports calling `async` functions from Ruby. 
-The Ruby call will happen synchronously, i.e. it will block until the JS function resolves:
+The Ruby call will happen synchronously, i.e. it will block until the JS
+function resolves:
 
 ```ruby
 class SyncFoo < Nodo::Core
@@ -158,3 +172,42 @@ class SyncFoo < Nodo::Core
   JS
 end
 ```
+
+### Limiting function execution time
+
+The default timeout for a single JS function call is 60 seconds due to the
+`Net::HTTP` default. It can be overridden on a per-function basis:
+
+```ruby
+class Foo < Nodo::Core
+  function :sleep, timeout: 1, code: <<~'JS'
+    async (sec) => await new Promise(resolve => setTimeout(resolve, sec * 1000))
+  JS
+end
+
+Foo.new.sleep(2)
+=>  Nodo::TimeoutError raised
+```
+
+### Logging
+
+By default, JS errors will be logged to `STDOUT`.
+
+To set a custom logger:
+
+```ruby
+Nodo.logger = Logger.new('nodo.log')
+```
+
+In Rails applications, `Rails.logger` will automatically be set.
+
+### Debugging
+
+To get verbose debug output, set
+
+```ruby
+Nodo.debug = true
+```
+
+before instantiating any worker instances. The debug mode will be active during
+the current process run.

data/lib/nodo/client.rb

@@ -28,10 +28,10 @@ module Nodo
 
     def connect_unix
       s = Timeout.timeout(@open_timeout) { UNIXSocket.open(@socket_path) }
-      @socket = Net::BufferedIO.new(s)
-      @socket.read_timeout = @read_timeout
-      @socket.continue_timeout = @continue_timeout
-      @socket.debug_output = @debug_output
+      @socket = Net::BufferedIO.new(s, read_timeout: @read_timeout,
+                                       write_timeout: @write_timeout,
+                                       continue_timeout: @continue_timeout,
+                                       debug_output: @debug_output)
       on_connect
     end
   end

data/lib/nodo/core.rb

@@ -12,6 +12,7 @@ module Nodo
     @@mutex = Mutex.new
     
     class << self
+      extend Forwardable
       
       attr_accessor :class_defined
       
@@ -25,6 +26,10 @@ module Nodo
         @instance ||= new
       end
       
+      def class_function(*methods)
+        singleton_class.def_delegators(:instance, *methods)
+      end
+      
       def class_defined?
         !!class_defined
       end
@@ -57,8 +62,13 @@ module Nodo
         self.dependencies = dependencies + mods.merge(deps).map { |name, package| Dependency.new(name, package) }
       end
 
-      def function(name, code)
-        self.functions = functions.merge(name => Function.new(name, code, caller.first))
+      def function(name, _code = nil, timeout: 60, code: nil)
+        raise ArgumentError, "reserved method name #{name.inspect}" if Nodo::Core.method_defined?(name) || name.to_s == DEFINE_METHOD
+        code = (code ||= _code).strip
+        raise ArgumentError, 'function code is required' if '' == code
+        loc = caller_locations(1, 1)[0]
+        source_location = "#{loc.path}:#{loc.lineno}: in `#{name}'"
+        self.functions = functions.merge(name => Function.new(name, _code || code, source_location, timeout))
         define_method(name) { |*args| call_js_method(name, args) }
       end
       
@@ -80,11 +90,13 @@ module Nodo
             process.exit(1);
           }
           
+          process.title = `nodo-core ${socket}`;
+          
           const shutdown = () => {
             nodo.core.close(() => { process.exit(0) });
           };
 
-          process.on('SIGINT', shutdown);
+          // process.on('SIGINT', shutdown);
           process.on('SIGTERM', shutdown);
 
           nodo.core.run(socket);
@@ -104,16 +116,6 @@ module Nodo
           })()
         JS
       end
-
-      protected
-
-      def finalize(pid, tmpdir)
-        proc do
-          Process.kill(:SIGTERM, pid)
-          Process.wait(pid)
-          FileUtils.remove_entry(tmpdir) if File.directory?(tmpdir)
-        end
-      end
       
       private
       
@@ -146,6 +148,11 @@ module Nodo
       self.class.clsid
     end
     
+    def log_exception(e)
+      return unless logger = Nodo.logger
+      logger.error "\n#{e.class} (#{e.message}):\n\n#{e.backtrace.join("\n")}"
+    end
+    
     def ensure_process_is_spawned
       return if node_pid
       spawn_process
@@ -155,23 +162,32 @@ module Nodo
       return if self.class.class_defined?
       call_js_method(DEFINE_METHOD, self.class.generate_class_code)
       self.class.class_defined = true
-#    rescue => e
- #     raise Error, e.message
     end
-
+    
     def spawn_process
       @@tmpdir = Pathname.new(Dir.mktmpdir('nodo'))
       env = Nodo.env.merge('NODE_PATH' => Nodo.modules_root.to_s)
-      @@node_pid = Process.spawn(env, Nodo.binary, '-e', self.class.generate_core_code, '--', socket_path.to_s)
-      ObjectSpace.define_finalizer(self, self.class.send(:finalize, node_pid, tmpdir))
+      env['NODO_DEBUG'] = '1' if Nodo.debug
+      @@node_pid = Process.spawn(env, Nodo.binary, '-e', self.class.generate_core_code, '--', socket_path.to_s, err: :out)
+      at_exit do
+        Process.kill(:SIGTERM, node_pid) rescue Errno::ECHILD
+        Process.wait(node_pid) rescue Errno::ECHILD
+        FileUtils.remove_entry(tmpdir) if File.directory?(tmpdir)
+      end
     end
     
     def wait_for_socket
       start = Time.now
-      until socket_path.exist?
-        raise TimeoutError, "socket #{socket_path} not found" if Time.now - start > TIMEOUT
-        sleep(0.2)
+      socket = nil
+      while Time.now - start < TIMEOUT
+        begin
+          break if socket = UNIXSocket.new(socket_path)
+        rescue Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTDIR
+          Kernel.sleep(0.2)
+        end
       end
+      socket.close if socket
+      raise TimeoutError, "could not connect to socket #{socket_path}" unless socket
     end
 
     def call_js_method(method, args)
@@ -182,12 +198,15 @@ module Nodo
       request = Net::HTTP::Post.new("/#{clsid}/#{method}", 'Content-Type': 'application/json')
       request.body = JSON.dump(args)
       client = Client.new("unix://#{socket_path}")
+      client.read_timeout = function.timeout if function
       response = client.request(request)
       if response.is_a?(Net::HTTPOK)
         parse_response(response)
       else
         handle_error(response, function)
       end
+    rescue Net::ReadTimeout
+      raise TimeoutError, "function call #{self.class}##{method} timed out"
     rescue Errno::EPIPE, IOError
       # TODO: restart or something? If this happens the process is completely broken
       raise Error, 'Node process failed'
@@ -196,13 +215,25 @@ module Nodo
     def handle_error(response, function)
       if response.body
         result = parse_response(response)
-        raise JavaScriptError.new(result['error'], function) if result.is_a?(Hash) && result.key?('error')
+        error = JavaScriptError.new(result['error'], function) if result.is_a?(Hash) && result.key?('error')
       end
-      raise CallError, "Node returned #{response.code}"
+      error ||= CallError.new("Node returned #{response.code}")
+      log_exception(error)
+      raise error
     end
     
     def parse_response(response)
-      JSON.parse(response.body.force_encoding('UTF-8'))
+      data = response.body.force_encoding('UTF-8')
+      JSON.parse(data) unless data == ''
+    end
+    
+    def with_tempfile(name)
+      ext = File.extname(name)
+      result = nil
+      Tempfile.create([File.basename(name, ext), ext], tmpdir) do |file|
+        result = yield(file)
+      end
+      result
     end
     
   end

data/lib/nodo/function.rb

@@ -1,9 +1,9 @@
 module Nodo
   class Function
-    attr_reader :name, :code, :source_location
+    attr_reader :name, :code, :source_location, :timeout
   
-    def initialize(name, code, source_location)
-      @name, @code, @source_location = name, code, source_location
+    def initialize(name, code, source_location, timeout)
+      @name, @code, @source_location, @timeout = name, code, source_location, timeout
     end
   
     def to_js

data/lib/nodo/nodo.js

@@ -1,5 +1,6 @@
 module.exports = (function() {
   const DEFINE_METHOD = '__nodo_define_class__';
+  const DEBUG = process.env.NODO_DEBUG;
 
   const vm = require('vm');
   const http = require('http');
@@ -24,7 +25,7 @@ module.exports = (function() {
   function respond_with_error(res, code, name) {
     res.statusCode = code;
     const rendered = render_error(name);
-    log(`Error ${code} ${rendered}`);
+    debug(`Error ${code} ${rendered}`);
     res.end(rendered, 'utf8');
   }
   
@@ -35,22 +36,24 @@ module.exports = (function() {
     if (start) {
       timing = ` in ${(performance.now() - start).toFixed(2)}ms`;
     }
-    log(`Completed 200 OK${timing}`);
+    debug(`Completed 200 OK${timing}\n`);
   }
 
-  function log(message) {
-    // fs.appendFileSync('log/nodo.log', `${message}\n`);
-    // console.log(`[Nodo] ${message}`);
+  function debug(message) {
+    if (DEBUG) {
+      // fs.appendFileSync('log/nodo.log', `${message}\n`);
+      console.log(`[Nodo] ${message}`);
+    }
   }
   
   const core = {
     run: (socket) => {
-      log('Starting up...');
+      debug('Starting up...');
       server = http.createServer((req, res) => {
         const start = performance.now();
         
         res.setHeader('Content-Type', 'application/json');
-        log(`${req.method} ${req.url}`);
+        debug(`${req.method} ${req.url}`);
 
         if (req.method !== 'POST' || !req.url.startsWith('/')) {
           return respond_with_error(res, 405, 'Method Not Allowed');
@@ -103,12 +106,12 @@ module.exports = (function() {
 
       //server.maxConnections = 64;
       server.listen(socket, () => {
-        log(`server ready, listening on ${socket} (max connections: ${server.maxConnections})`);
+        debug(`server ready, listening on ${socket} (max connections: ${server.maxConnections})`);
       });
     },
     
     close: (finalizer) => {
-      log("Shutting down");
+      debug("Shutting down");
       if (!closing) {
         closing = true;
         server.close(finalizer);
@@ -116,5 +119,5 @@ module.exports = (function() {
     }
   };
   
-  return { core: core, log: log };
+  return { core: core, debug: debug };
 })();

data/lib/nodo/railtie.rb

@@ -4,5 +4,7 @@ require 'active_support'
 class Nodo::Railtie < Rails::Railtie
   initializer 'nodo' do |app|
     Nodo.modules_root = Rails.root.join('vendor', 'node_modules')
+    Nodo.env['NODE_ENV'] = Rails.env.to_s
+    Nodo.logger = Rails.logger
   end
 end

data/lib/nodo/version.rb

@@ -1,3 +1,3 @@
 module Nodo
-  VERSION = '1.5.1'
+  VERSION = '1.5.6'
 end

data/lib/nodo.rb

@@ -2,14 +2,20 @@ require 'pathname'
 require 'json'
 require 'fileutils'
 require 'tmpdir'
+require 'tempfile'
+require 'logger'
+require 'socket'
+require 'forwardable'
 
 module Nodo
   class << self
-    attr_accessor :modules_root, :env, :binary
+    attr_accessor :modules_root, :env, :binary, :logger, :debug
   end
   self.modules_root = './node_modules'
   self.env = {}
   self.binary = 'node'
+  self.logger = Logger.new(STDOUT)
+  self.debug  = false
 end
 
 require_relative 'nodo/version'
@@ -21,4 +27,4 @@ require_relative 'nodo/constant'
 require_relative 'nodo/client'
 require_relative 'nodo/core'
 
-require_relative 'nodo/railtie' if defined?(Rails)
+require_relative 'nodo/railtie' if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nodo
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.5.6
 platform: ruby
 authors:
 - Matthias Grosser
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-03 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Call Node.js from Ruby