polyphony 1.4 → 1.6

data/lib/polyphony/adapters/open3.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+# Adapted from https://github.com/ruby/open3/blob/master/lib/open3.rb
+
+module Open3
+
+  # Open3.capture3 captures the standard output and the standard error of a command.
+  #
+  #   stdout_str, stderr_str, status = Open3.capture3([env,] cmd... [, opts])
+  #
+  # The arguments env, cmd and opts are passed to Open3.popen3 except
+  # <code>opts[:stdin_data]</code> and <code>opts[:binmode]</code>.  See Process.spawn.
+  #
+  # If <code>opts[:stdin_data]</code> is specified, it is sent to the command's standard input.
+  #
+  # If <code>opts[:binmode]</code> is true, internal pipes are set to binary mode.
+  #
+  # Examples:
+  #
+  #   # dot is a command of graphviz.
+  #   graph = <<'End'
+  #     digraph g {
+  #       a -> b
+  #     }
+  #   End
+  #   drawn_graph, dot_log = Open3.capture3("dot -v", :stdin_data=>graph)
+  #
+  #   o, e, s = Open3.capture3("echo abc; sort >&2", :stdin_data=>"foo\nbar\nbaz\n")
+  #   p o #=> "abc\n"
+  #   p e #=> "bar\nbaz\nfoo\n"
+  #   p s #=> #<Process::Status: pid 32682 exit 0>
+  #
+  #   # generate a thumbnail image using the convert command of ImageMagick.
+  #   # However, if the image is really stored in a file,
+  #   # system("convert", "-thumbnail", "80", "png:#{filename}", "png:-") is better
+  #   # because of reduced memory consumption.
+  #   # But if the image is stored in a DB or generated by the gnuplot Open3.capture2 example,
+  #   # Open3.capture3 should be considered.
+  #   #
+  #   image = File.read("/usr/share/openclipart/png/animals/mammals/sheep-md-v0.1.png", :binmode=>true)
+  #   thumbnail, err, s = Open3.capture3("convert -thumbnail 80 png:- png:-", :stdin_data=>image, :binmode=>true)
+  #   if s.success?
+  #     STDOUT.binmode; print thumbnail
+  #   end
+  #
+  def capture3(*cmd)
+    if Hash === cmd.last
+      opts = cmd.pop.dup
+    else
+      opts = {}
+    end
+
+    stdin_data = opts.delete(:stdin_data) || ''
+    binmode = opts.delete(:binmode)
+
+    popen3(*cmd, opts) {|i, o, e, t|
+      if binmode
+        i.binmode
+        o.binmode
+        e.binmode
+      end
+      out_reader = spin { o.read }
+      err_reader = spin { e.read }
+      begin
+        if stdin_data.respond_to? :readpartial
+          IO.double_splice(stdin_data, i)
+        else
+          i.write stdin_data
+        end
+      rescue Errno::EPIPE
+      end
+      i.close
+      [out_reader.value, err_reader.value, t.value]
+    }
+  end
+  module_function :capture3
+
+  # Open3.capture2 captures the standard output of a command.
+  #
+  #   stdout_str, status = Open3.capture2([env,] cmd... [, opts])
+  #
+  # The arguments env, cmd and opts are passed to Open3.popen3 except
+  # <code>opts[:stdin_data]</code> and <code>opts[:binmode]</code>.  See Process.spawn.
+  #
+  # If <code>opts[:stdin_data]</code> is specified, it is sent to the command's standard input.
+  #
+  # If <code>opts[:binmode]</code> is true, internal pipes are set to binary mode.
+  #
+  # Example:
+  #
+  #   # factor is a command for integer factorization.
+  #   o, s = Open3.capture2("factor", :stdin_data=>"42")
+  #   p o #=> "42: 2 3 7\n"
+  #
+  #   # generate x**2 graph in png using gnuplot.
+  #   gnuplot_commands = <<"End"
+  #     set terminal png
+  #     plot x**2, "-" with lines
+  #     1 14
+  #     2 1
+  #     3 8
+  #     4 5
+  #     e
+  #   End
+  #   image, s = Open3.capture2("gnuplot", :stdin_data=>gnuplot_commands, :binmode=>true)
+  #
+  def capture2(*cmd)
+    if Hash === cmd.last
+      opts = cmd.pop.dup
+    else
+      opts = {}
+    end
+
+    stdin_data = opts.delete(:stdin_data)
+    binmode = opts.delete(:binmode)
+
+    popen2(*cmd, opts) {|i, o, t|
+      if binmode
+        i.binmode
+        o.binmode
+      end
+      out_reader = spin { o.read }
+      if stdin_data
+        begin
+          if stdin_data.respond_to? :readpartial
+            IO.double_splice(stdin_data, i)
+          else
+            i.write stdin_data
+          end
+        rescue Errno::EPIPE
+        end
+      end
+      i.close
+      [out_reader.value, t.value]
+    }
+  end
+  module_function :capture2
+
+  # Open3.capture2e captures the standard output and the standard error of a command.
+  #
+  #   stdout_and_stderr_str, status = Open3.capture2e([env,] cmd... [, opts])
+  #
+  # The arguments env, cmd and opts are passed to Open3.popen3 except
+  # <code>opts[:stdin_data]</code> and <code>opts[:binmode]</code>.  See Process.spawn.
+  #
+  # If <code>opts[:stdin_data]</code> is specified, it is sent to the command's standard input.
+  #
+  # If <code>opts[:binmode]</code> is true, internal pipes are set to binary mode.
+  #
+  # Example:
+  #
+  #   # capture make log
+  #   make_log, s = Open3.capture2e("make")
+  #
+  def capture2e(*cmd)
+    if Hash === cmd.last
+      opts = cmd.pop.dup
+    else
+      opts = {}
+    end
+
+    stdin_data = opts.delete(:stdin_data)
+    binmode = opts.delete(:binmode)
+
+    popen2e(*cmd, opts) {|i, oe, t|
+      if binmode
+        i.binmode
+        oe.binmode
+      end
+      outerr_reader = spin { oe.read }
+      if stdin_data
+        begin
+          if stdin_data.respond_to? :readpartial
+            IO.double_splice(stdin_data, i)
+          else
+            i.write stdin_data
+          end
+        rescue Errno::EPIPE
+          # ignore
+        end
+      end
+      i.close
+      [outerr_reader.value, t.value]
+    }
+  end
+  module_function :capture2e
+end
+
+# JRuby uses different popen logic on Windows, require it here to reuse wrapper methods above.
+require 'open3/jruby_windows' if RUBY_ENGINE == 'jruby' && JRuby::Util::ON_WINDOWS

data/lib/polyphony/core/sync.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'monitor'
+
 module Polyphony
   # Implements mutex lock for synchronizing access to a shared resource. This
   # class replaces the stock `Thread::Mutex` class.
@@ -27,8 +29,7 @@ module Polyphony
     #
     # @return [nil]
     def conditional_release
-      @store << @token
-      @token = nil
+      @store << true
       @holding_fiber = nil
     end
 
@@ -37,7 +38,7 @@ module Polyphony
     #
     # @return [Fiber] current fiber
     def conditional_reacquire
-      @token = @store.shift
+      @store.shift
       @holding_fiber = Fiber.current
     end
 
@@ -60,9 +61,10 @@ module Polyphony
     #
     # @return [Mutex] self
     def lock
+      check_dead_holder
       raise ThreadError if owned?
 
-      @token = @store.shift
+      @store.shift
       @holding_fiber = Fiber.current
       self
     end
@@ -75,8 +77,7 @@ module Polyphony
       raise ThreadError if !owned?
 
       @holding_fiber = nil
-      @store << @token if @token
-      @token = nil
+      @store << true
     end
 
     # Attempts to obtain the lock and returns immediately. Returns `true` if the
@@ -86,7 +87,7 @@ module Polyphony
     def try_lock
       return false if @holding_fiber
 
-      @token = @store.shift
+      @store.shift
       @holding_fiber = Fiber.current
       true
     end
@@ -114,16 +115,79 @@ module Polyphony
     #
     # @return [any] return value of given block.
     def synchronize_not_holding
-      @token = @store.shift
+      @store.shift
       begin
         @holding_fiber = Fiber.current
         yield
       ensure
         @holding_fiber = nil
-        @store << @token if @token
-        @token = nil
+        @store << true
+      end
+    end
+
+    def check_dead_holder
+      return if !@holding_fiber&.dead?
+
+      @holding_fiber = nil
+      @store << true
+    end
+  end
+
+  # Implements a fiber-aware Monitor class. This class replaces the stock
+  # `Monitor` class.
+  class Monitor < Mutex
+    def enter
+      if @holding_fiber == Fiber.current
+        @holding_count += 1
+      else
+        lock
+        @holding_count = 1
+      end
+    end
+    alias_method :mon_enter, :enter
+
+    def exit
+      raise ThreadError if !owned?
+
+      @holding_count -= 1
+      unlock if @holding_count == 0
+    end
+    alias_method :mon_exit, :exit
+
+    def mon_check_owner
+      if Fiber.current == @holding_fiber
+        nil
+      else
+        raise ThreadError, 'current fiber not owner'
       end
     end
+
+    def mon_locked?
+      !!@holding_fiber
+    end
+
+    def mon_owned?
+      @holding_fiber == Fiber.current
+    end
+
+    alias_method :mon_synchronize, :synchronize
+
+    def new_cond
+      MonitorMixin::ConditionVariable.new(self)
+    end
+
+    def try_enter
+      check_dead_holder
+      return false if @holding_fiber
+
+      enter
+      true
+    end
+    alias_method :try_mon_enter, :try_enter
+
+    def wait_for_cond(cond, timeout)
+      cond.wait(self, timeout)
+    end
   end
 
   # Implements a fiber-aware ConditionVariable
@@ -136,12 +200,18 @@ module Polyphony
     # Waits for the condition variable to be signalled.
     #
     # @param mutex [Polyphony::Mutex] mutex to release while waiting for signal
-    # @param _timeout [Number, nil] timeout in seconds (currently not implemented)
+    # @param timeout [Number, nil] timeout in seconds, or nil for no timeout
     # @return [any]
-    def wait(mutex, _timeout = nil)
+    def wait(mutex, timeout = nil)
       mutex.conditional_release
       @queue << Fiber.current
-      Polyphony.backend_wait_event(true)
+      if timeout
+        move_on_after(timeout, with_value: false) { Polyphony.backend_wait_event(true); true }
+      else
+        Polyphony.backend_wait_event(true)
+        true
+      end
+    ensure
       mutex.conditional_reacquire
     end
 

data/lib/polyphony/core/timer.rb

@@ -192,38 +192,20 @@ module Polyphony
       ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
     end
 
-    # Converts a timeout record's exception spec to an exception instance.
-    #
-    # @param record [Array, Class, Exception, String] exception spec
-    # @return [Exception] exception instance
-    def timeout_exception(record)
-      case (exception = record[:exception])
-      when Array
-        exception[0].new(exception[1])
-      when Class
-        exception.new
-      when Exception
-        exception
-      else
-        RuntimeError.new(exception)
-      end
-    end
-
     # Runs a timer iteration, invoking any timeouts that are due.
     def update
       return if @timeouts.empty?
 
-      @timeouts.each do |fiber, record|
-        next if record[:target_stamp] > now
+      @timeouts.each do |f, r|
+        next if r[:target_stamp] > now
 
-        value = record[:exception] ? timeout_exception(record) : record[:value]
-        fiber.schedule value
+        f.schedule(
+          r[:exception] ? Exception.instantiate(r[:exception]) : r[:value]
+        )
 
-        next unless record[:recurring]
+        next if !r[:recurring]
 
-        while record[:target_stamp] <= now
-          record[:target_stamp] += record[:interval]
-        end
+        r[:target_stamp] += r[:interval] while r[:target_stamp] <= now
       end
     end
   end

data/lib/polyphony/extensions/exception.rb

@@ -6,6 +6,21 @@ class ::Exception
     # Set to true to disable sanitizing the backtrace (to remove frames occuring
     # in the Polyphony code itself.)
     attr_accessor :__disable_sanitized_backtrace__
+
+    # Creates an exception instance from the given error according to its type.
+    #
+    # @param error [nil, String, Class, Exception] error
+    # @param message [nil, String] error message
+    # @return [Exception] exception instance
+    def instantiate(error = nil, message = nil)
+      case error
+      when String then    RuntimeError.new(error)
+      when Array then     error[0].new(error[1])
+      when Class then     error.new(message)
+      when Exception then error
+      else                RuntimeError.new
+      end
+    end
   end
 
   # Set to the fiber in which the exception was *originally* raised (in case the

data/lib/polyphony/extensions/fiber.rb

@@ -167,7 +167,7 @@ class ::Fiber
   #   @param any [Exception] exception to raise
   #   @return [Fiber] self
   def raise(*args)
-    error = error_from_raise_args(args)
+    error = Exception.instantiate(*args)
     schedule(error)
     self
   end
@@ -182,13 +182,24 @@ class ::Fiber
     raise Polyphony::Interjection.new(block)
   end
 
-  # Blocks until the fiber has terminated, returning its return value.
+  # Waits for the fiber to terminate, and returns its return value (the result
+  # of its last statement). If the fiber has terminated with an ancaught
+  # exception, the exception will be raised.
   #
-  # @return [any] fiber's return value
+  #     f = spin { :foo; :bar }
+  #     f.await #=> :bar
+  #
+  # @overload await
+  #   @return [any] fiber's return value
+  # @overload join
+  #   @return [any] fiber's return value
+  # @overload value
+  #   @return [any] fiber's return value
   def await
     Fiber.await(self).first
   end
   alias_method :join, :await
+  alias_method :value, :await
 
   #############################
   # Fiber supervision methods #
@@ -648,16 +659,6 @@ class ::Fiber
 
   private
 
-  # @!visibility private
-  def error_from_raise_args(args)
-    case (arg = args.shift)
-    when String then RuntimeError.new(arg)
-    when Class  then arg.new(args.shift)
-    when Exception then arg
-    else RuntimeError.new
-    end
-  end
-
   # @!visibility private
   def supervise_opts_to_block(opts)
     block = opts[:on_done] || opts[:on_error]

data/lib/polyphony/extensions/io.rb

@@ -59,12 +59,12 @@ class ::IO
       end
     end
 
-    # alias_method :orig_readlines, :readlines
-    # def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
-    #   File.open(name, 'r') do |f|
-    #     f.readlines(sep, limit, getline_args)
-    #   end
-    # end
+    alias_method :orig_readlines, :readlines
+    def readlines(name, sep = $/, limit = nil, getline_args = EMPTY_HASH)
+      File.open(name, 'r') do |f|
+        f.readlines(sep, **getline_args)
+      end
+    end
 
     # @!visibility private
     alias_method :orig_write, :write
@@ -87,6 +87,42 @@ class ::IO
       Open3.popen2(cmd) { |_i, o, _t| yield o }
     end
 
+    def copy_stream(src, dst, src_length = nil, src_offset = 0)
+      close_src = false
+      close_dst = false
+      if !src.respond_to?(:readpartial)
+        src = File.open(src, 'r+')
+        close_src = true
+      end
+      if !dst.respond_to?(:readpartial)
+        dst = File.open(dst, 'w+')
+        close_dst = true
+      end
+      src.seek(src_offset) if src_offset > 0
+
+      pipe = Polyphony::Pipe.new
+
+      pipe_to_dst = spin { dst.splice_from(pipe, -65536) }
+
+      count = 0
+      if src_length
+        while count < src_length
+          count += pipe.splice_from(src, src_length)
+        end
+      else
+        count = pipe.splice_from(src, -65536)
+      end
+      
+      pipe.close
+      pipe_to_dst.await
+      
+      count
+    ensure
+      pipe_to_dst&.stop
+      src.close if close_src
+      dst.close if close_dst
+    end
+
     # Splices from one IO to another IO. At least one of the IOs must be a pipe.
     # If maxlen is negative, splices repeatedly using absolute value of maxlen
     # until EOF is encountered.
@@ -109,6 +145,17 @@ class ::IO
       Polyphony.backend_double_splice(src, dest)
     end
 
+    if !Polyphony.respond_to?(:backend_double_splice)
+      def double_splice(src, dest)
+        pipe = Polyphony::Pipe.new
+        f = spin { Polyphony.backend_splice(pipe, dest, -65536) }
+        Polyphony.backend_splice(src, pipe, -65536)
+        pipe.close
+      ensure
+        f.stop
+      end
+    end
+
     # Tees data from the source to the desination.
     #
     # @param src [IO, Polyphony::Pipe] source to tee from
@@ -120,11 +167,6 @@ class ::IO
     end
 
     if RUBY_PLATFORM !~ /linux/
-      # @!visibility private
-      def double_splice(src, dest)
-        raise NotImplementedError
-      end
-
       # @!visibility private
       def tee(src, dest, maxlen)
         raise NotImplementedError
@@ -203,7 +245,7 @@ class ::IO
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
-    return nil unless result
+    return '' unless result
 
     already_read = @read_buffer
     @read_buffer = +''
@@ -280,7 +322,7 @@ class ::IO
         yield line
       end
 
-      result = readpartial(8192, @read_buffer, -1)
+      result = Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
       return self if !result
     end
   rescue EOFError
@@ -436,7 +478,7 @@ class ::IO
   def close
     return if closed?
 
-    Polyphony.backend_close(self)
+    Polyphony.backend_close(self) rescue nil
     nil
   end
 

data/lib/polyphony/extensions/kernel.rb

@@ -123,7 +123,7 @@ module ::Kernel
         i.close
         pipe_to_eof(o, $stdout)
       end
-      waiter.await.last == 0
+      waiter.value.success?
     rescue SystemCallError
       nil
     end

data/lib/polyphony/extensions/object.rb

@@ -240,7 +240,7 @@ class ::Object
     fiber = Fiber.current
     canceller = spin do
       Polyphony.backend_sleep(interval)
-      exception = cancel_exception(exception)
+      exception = Exception.instantiate(exception)
       exception.raising_fiber = Fiber.current
       fiber.cancel(exception)
     end
@@ -249,18 +249,6 @@ class ::Object
     canceller.stop
   end
 
-  # Converts the given exception spec to an exception instance.
-  #
-  # @param exception [Exception, Class, Array<class, message>] exception spec
-  # @return [Exception] exception instance
-  def cancel_exception(exception)
-    case exception
-    when Class then exception.new
-    when Array then exception[0].new(exception[1])
-    else RuntimeError.new(exception)
-    end
-  end
-
   # Helper method for performing `#spin_loop` without throttling. Spins up a
   # new fiber in which to run the loop.
   #