binaryen 1.1.6.6 → 1.1.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44bf5b373ce186bdee3006d16e8129bde2be3e952c1211d3ee550fb529cffbfe
-  data.tar.gz: c3ef7a60460cdc937e51b538ef4e6d94ebfba2167ff14821292881a9b91d6f1f
+  metadata.gz: 4217d4168d453c8e5316e9c66929d5e09057ec356dc6f80802c41521de6fd612
+  data.tar.gz: 2cb4b068c0456d72dcc55cf0d945a5357df0d3ad8c82166fca8a57dcd2908ec4
 SHA512:
-  metadata.gz: 290897e4df9079e57df51b4b684fa5ae496ea414c44d801ed8d2be5c167d5347812533511ee26b8f59520d645df1072df5c6368d218ab824d89b38e07373e7b5
-  data.tar.gz: c30ed5adcb899a8d938d211b3aa3e98e875ec061f19054efd5d7a803b9be0392f9215cbac61283147841e23171ead48391f06695aa06841a64a6be05d5ba57aa
+  metadata.gz: 9e3fd947316b466a8d592014bc57b1c34148da5b3042e0630b2bc5f56e54c287ab4c6416e78c1ef392e88429cbbcba0c0c3549bdd8b99d7068972c1adeb0c698
+  data.tar.gz: 2cdfe8e57ab692f16e911e7a819cb6cfecbf9b31027a04c8863eb919fd952cb6d92832d3884768cf05704507c7c408bcfb19eed3c47b90dfcbb6f1e7eaefc679

data/lib/binaryen/command.rb

@@ -1,131 +1,108 @@
 # frozen_string_literal: true
 
-require "English"
-require "shellwords"
-require "timeout"
 require "posix/spawn"
+require "timeout"
+require "tempfile"
 
 module Binaryen
-  # Wrapper around a binaryen executable command with a timeout and streaming IO.
-  #
-  # @example Running wasm-opt
-  #
-  #   ```ruby
-  #   command = Binaryen::Command.new("wasm-opt", timeout: 10)
-  #   optimized_wasm = command.run("-O4", stdin: "(module)")
-  #   ```
   class Command
     include POSIX::Spawn
-
+    DEFAULT_MAX_OUTPUT_SIZE = 256 * 1024 * 1024
+    DEFAULT_TIMEOUT = 10
     DEFAULT_ARGS_FOR_COMMAND = {
       "wasm-opt" => ["--output=-"],
     }.freeze
 
-    class TimeoutChecker
-      def initialize(end_time:, pid:)
-        @end_time = end_time
-        @pid = pid
-      end
-
-      def check!
-        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        if now >= @end_time
-          Process.kill("TERM", @pid)
-          raise Timeout::Error, "Command timed out"
-        end
-        remaining_time = @end_time - now
-        remaining_time
-      end
-    end
-
-    def initialize(cmd, timeout: 10, ignore_missing: false)
+    def initialize(cmd, timeout: DEFAULT_TIMEOUT, max_output_size: DEFAULT_MAX_OUTPUT_SIZE, ignore_missing: false)
       @cmd = command_path(cmd, ignore_missing) || raise(ArgumentError, "command not found: #{cmd}")
       @timeout = timeout
       @default_args = DEFAULT_ARGS_FOR_COMMAND.fetch(cmd, [])
+      @max_output_size = max_output_size
     end
 
     def run(*arguments, stdin: nil, stderr: nil)
-      end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) + @timeout
-      command = build_command(*arguments)
-      pid, iwr, ord, erd = popen4(*command)
-      timeout_checker = TimeoutChecker.new(end_time: end_time, pid: pid)
-
-      write_to_pipe(iwr, stdin, timeout_checker, pid) if stdin
+      args = [@cmd] + arguments + @default_args
 
-      if stderr
-        err_output = read_from_pipe(erd, timeout_checker)
-        write_to_pipe(stderr, err_output, timeout_checker, pid, close_write: false)
+      if stdin
+        with_stdin_tempfile(stdin) { |path| spawn_command(*args, path, stderr: stderr) }
+      else
+        spawn_command(*args, stderr: stderr)
       end
-      output = read_from_pipe(ord, timeout_checker)
-      wait_or_kill(pid, timeout_checker)
-
-      output
     end
 
     private
 
-    def write_to_pipe(pipe, stdin, timeout_checker, pid, close_write: true)
-      offset = 0
-      length = stdin.bytesize
-
-      while offset < length
-        remaining_time = timeout_checker.check!
-
-        next unless IO.select(nil, [pipe], nil, remaining_time)
-
-        begin
-          written = pipe.write_nonblock(stdin.byteslice(offset, length), exception: false)
-          offset += written if written.is_a?(Integer)
-        rescue Errno::EPIPE
-          wait_or_kill(pid, timeout_checker, pid)
-        end
+    def with_stdin_tempfile(content)
+      Tempfile.open("binaryen-stdin") do |f|
+        f.binmode
+        f.write(content)
+        f.close
+        yield f.path
       end
-    ensure
-      pipe.close_write if close_write
     end
 
-    def read_from_pipe(pipe, timeout_checker, close_read: true)
-      output = +""
-
-      while (result = pipe.read_nonblock(8192, exception: false))
-        remaining_time = timeout_checker.check!
-
-        case result
-        when :wait_readable
-          IO.select([pipe], nil, nil, remaining_time)
-        when nil
-          break
-        else
-          output << result
-        end
-      end
-
-      output
-    ensure
-      pipe.close_read if close_read
+    def command_path(cmd, ignore_missing)
+      Dir[File.join(Binaryen.bindir, cmd)].first || (ignore_missing && cmd)
     end
 
-    def wait_or_kill(pid, timeout_checker)
-      loop do
-        timeout_checker.check!
+    def spawn_command(*args, stderr: nil)
+      out = "".b
+      data_buffer = "".b
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      pid, stdin, stdout, stderr_stream = popen4(*args)
+      stdin.close
+      @pid = pid
+      readers = [stdout, stderr_stream]
+
+      while readers.any?
+        elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        remaining_time = @timeout - elapsed_time
+        ready = IO.select(readers, nil, nil, remaining_time)
+        raise Timeout::Error, "command timed out after #{@timeout} seconds" if ready.nil?
+
+        ready[0].each do |io|
+          max_amount_to_read = @max_output_size - out.bytesize + 1
+          data = io.read_nonblock(max_amount_to_read, data_buffer, exception: false)
+
+          if data == :wait_readable
+            # If the IO object is not ready for reading, read_nonblock returns :wait_readable.
+            # This isn't an error, but a notification.
+            next
+          elsif data.nil?
+            # At EOF, read_nonblock returns nil instead of raising EOFError.
+            readers.delete(io)
+          elsif io == stdout
+            out << data_buffer
+          elsif io == stderr_stream && stderr
+            stderr << data_buffer
+          end
+        rescue Errno::EPIPE, Errno::EINTR
+          # Handle EPIPE and EINTR errors
+          readers.delete(io)
+        end
 
-        if (_, status = Process.wait2(pid, Process::WNOHANG))
-          raise Binaryen::NonZeroExitStatus,
-            "command exited with status #{status.exitstatus}" if status.exitstatus != 0
+        if out.bytesize > @max_output_size
+          Process.kill("TERM", @pid)
+          raise Binaryen::MaximumOutputExceeded, "maximum output size exceeded (#{@max_output_size} bytes)"
+        end
 
-          return true
-        else
-          sleep(0.1)
+        if remaining_time < 0
+          Process.kill("TERM", @pid)
+          raise Timeout::Error, "command timed out after #{@timeout} seconds"
         end
       end
-    end
 
-    def build_command(*arguments)
-      [@cmd] + arguments + @default_args
-    end
+      _, status = Process.waitpid2(pid, Process::WUNTRACED)
 
-    def command_path(cmd, ignore_missing)
-      Dir[File.join(Binaryen.bindir, cmd)].first || (ignore_missing && cmd)
+      raise Binaryen::NonZeroExitStatus, "command exited with status #{status.exitstatus}" unless status.success?
+
+      out
+    ensure
+      [stdin, stdout, stderr_stream].each do |io|
+        io.close
+      rescue
+        nil
+      end
     end
   end
 end

data/lib/binaryen/error.rb

@@ -3,4 +3,5 @@
 module Binaryen
   class Error < StandardError; end
   class NonZeroExitStatus < Error; end
+  class MaximumOutputExceeded < Error; end
 end

data/lib/binaryen/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Binaryen
-  VERSION = "1.1.6.6"
+  VERSION = "1.1.6.8"
   BINARYEN_VERSION = "version_116"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: binaryen
 version: !ruby/object:Gem::Version
-  version: 1.1.6.6
+  version: 1.1.6.8
 platform: ruby
 authors:
 - Shopify Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-18 00:00:00.000000000 Z
+date: 2023-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: posix-spawn