nodo 1.5.0 → 1.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f997b2c506f2cec9bfd235c68cb0db93fcb103fa7f9b40f03740ca27b59ffb4
-  data.tar.gz: 8a1ba6ae691ee2a992b2af5a127c43c70178cc403134db04a08f9597dd8588b3
+  metadata.gz: 3cef66bc4b1d53b20500110ac7acbc226ec361b6aaed569874ce8568a6718242
+  data.tar.gz: ab2cae6eef01d53ebc1c471a5e08edfd37a263178adc49aa459c98dfcea4e92f
 SHA512:
-  metadata.gz: 77c7a96627569da1b4093eb0fbfb6ab94c0c7dae4e425b019d52e06183f098daac57b88f68924fbe117afc1a0cf8be3aec143fd8e6935c839ebd573dde5afd70
-  data.tar.gz: 8057351d0968d8bc357af3926b805f82ce6e05949ee54efb9df40293ba4faf0ce8d337550318de0114c7f9dc2df05958ea481dc35aa2981a0d95501c9cb18c64
+  metadata.gz: 9bf90e8b56366f2e42039026575db43a0c5a9808a677a533c3e211c9ae211a8f06b2ea0890550e22fca259f9fa416c0e96017a676538a3eb673f2a66caa0996a
+  data.tar.gz: 2573e2dfd199bb9f8e25dc11c5dcb49e0ba6f29796aaa523656fa1020e0d8ce325ab411cf2d60413ac0557407fec4a132ba51d75075585a0e7b56d76bfc42811

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`.
@@ -117,12 +129,62 @@ end
 class BarFoo < Nodo::Core
 
   script <<~JS
-    // some custom JS
-    // to be executed during initialization
+    // custom JS to be executed during initialization
+    // things defined here can later be used inside functions
+    const bigThing = someLib.init();
   JS
 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
+  function :foo, "() => 'superclass'"
+end
+
+class SubFoo < Foo
+  function :bar, "() => { return 'calling' + foo() }"
+end
+
+class SubSubFoo < SubFoo
+  function :foo, "() => 'subsubclass'"
+end
+
+Foo.new.foo => "superclass"
+SubFoo.new.bar => "callingsuperclass"
+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:
+
+```ruby
+class SyncFoo < Nodo::Core
+  function :do_something, <<~JS
+    async () => { return await asyncFunc(); }
+  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
+```

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,11 @@ 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) 
+        code = (code ||= _code).strip
+        raise ArgumentError, 'function code is required' if '' == code
+        self.functions = functions.merge(name => Function.new(name, _code || code, caller.first, timeout))
         define_method(name) { |*args| call_js_method(name, args) }
       end
       
@@ -80,6 +88,8 @@ module Nodo
             process.exit(1);
           }
           
+          process.title = `nodo-core ${socket}`;
+          
           const shutdown = () => {
             nodo.core.close(() => { process.exit(0) });
           };
@@ -104,16 +114,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
       
@@ -155,23 +155,31 @@ 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))
+      @@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 +190,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'
@@ -202,7 +213,17 @@ module Nodo
     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

@@ -0,0 +1,120 @@
+module.exports = (function() {
+  const DEFINE_METHOD = '__nodo_define_class__';
+
+  const vm = require('vm');
+  const http = require('http');
+  const path = require('path');
+  const fs = require('fs');
+  const performance = require('perf_hooks').performance;
+  
+  let server, closing;
+  const classes = {};
+  
+  function render_error(e) {
+    let errInfo = {};
+    if (e instanceof Error) {
+      errInfo.name = e.name;
+      Object.getOwnPropertyNames(e).reduce((obj, prop) => { obj[prop] = e[prop]; return obj }, errInfo);
+    } else {
+      errInfo.name = e.toString();
+    }
+    return JSON.stringify({ error: errInfo });
+  }
+
+  function respond_with_error(res, code, name) {
+    res.statusCode = code;
+    const rendered = render_error(name);
+    log(`Error ${code} ${rendered}`);
+    res.end(rendered, 'utf8');
+  }
+  
+  function respond_with_data(res, data, start) {
+    let timing;
+    res.statusCode = 200;
+    res.end(JSON.stringify(data), 'utf8');
+    if (start) {
+      timing = ` in ${(performance.now() - start).toFixed(2)}ms`;
+    }
+    log(`Completed 200 OK${timing}`);
+  }
+
+  function log(message) {
+    // fs.appendFileSync('log/nodo.log', `${message}\n`);
+    // console.log(`[Nodo] ${message}`);
+  }
+  
+  const core = {
+    run: (socket) => {
+      log('Starting up...');
+      server = http.createServer((req, res) => {
+        const start = performance.now();
+        
+        res.setHeader('Content-Type', 'application/json');
+        log(`${req.method} ${req.url}`);
+
+        if (req.method !== 'POST' || !req.url.startsWith('/')) {
+          return respond_with_error(res, 405, 'Method Not Allowed');
+        }
+        
+        const url = req.url.substring(1);
+        const [class_name, method] = url.split('/');
+        let klass;
+        
+        if (classes.hasOwnProperty(class_name)) {
+          klass = classes[class_name];
+          if (!klass.hasOwnProperty(method)) {
+            return respond_with_error(res, 404, `Method ${class_name}#${method} not found`);
+          }
+        } else if (DEFINE_METHOD != method) {
+          return respond_with_error(res, 404, `Class ${class_name} not defined`);
+        }
+        
+        let body = '';
+        
+        req.on('data', (data) => { body += data; });
+
+        req.on('end', () => {
+          let input, result;
+
+          try {
+            input = JSON.parse(body);
+          } catch (e) {
+            return respond_with_error(res, 400, 'Bad Request');
+          }
+
+          try {
+            if (DEFINE_METHOD == method) {
+              let new_class = vm.runInThisContext(input, class_name);
+              classes[class_name] = new_class;
+              respond_with_data(res, class_name, start);
+            } else {
+              Promise.resolve(klass[method].apply(null, input)).then(function (result) {
+                respond_with_data(res, result, start);
+              }).catch(function(error) {
+                respond_with_error(res, 500, error);
+              });
+            }
+          } catch(error) {
+            return respond_with_error(res, 500, error);
+          }
+    
+        });
+      });
+
+      //server.maxConnections = 64;
+      server.listen(socket, () => {
+        log(`server ready, listening on ${socket} (max connections: ${server.maxConnections})`);
+      });
+    },
+    
+    close: (finalizer) => {
+      log("Shutting down");
+      if (!closing) {
+        closing = true;
+        server.close(finalizer);
+      }
+    }
+  };
+  
+  return { core: core, log: log };
+})();

data/lib/nodo/version.rb

@@ -1,3 +1,3 @@
 module Nodo
-  VERSION = '1.5.0'
+  VERSION = '1.5.5'
 end

data/lib/nodo.rb

@@ -2,6 +2,9 @@ require 'pathname'
 require 'json'
 require 'fileutils'
 require 'tmpdir'
+require 'tempfile'
+require 'socket'
+require 'forwardable'
 
 module Nodo
   class << self
@@ -21,4 +24,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.0
+  version: 1.5.5
 platform: ruby
 authors:
 - Matthias Grosser
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,6 +82,7 @@ files:
 - lib/nodo/dependency.rb
 - lib/nodo/errors.rb
 - lib/nodo/function.rb
+- lib/nodo/nodo.js
 - lib/nodo/railtie.rb
 - lib/nodo/script.rb
 - lib/nodo/version.rb
@@ -89,7 +90,7 @@ homepage: https://github.com/mtgrosser/nodo
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,8 +105,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Call Node.js from Ruby
 test_files: []