parallel 1.27.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a657608c1d396b6c563f8905778d64d24c4ae6bb010e716e60a45ccc4a71295e
-  data.tar.gz: eb26d89f92521fed38f1bdf99f6374a2cca2e3f4c1557a7f3f92ed81d396ffb7
+  metadata.gz: 3331bc6634cd376e4f3f8511049e49a0d4501110aaeac395e2f0c0b638f4a402
+  data.tar.gz: 357e1424cb8297b6472c2c5b9486e26da3969edd928be7d6ca7f21670211a8e0
 SHA512:
-  metadata.gz: d7accf7f9b3d74e1e76f7b89db8f9040d23876e8373a6d6fa9b31e927b9ca4ce8b13330ffd888871795c79d6e3bbe7b17aa787789146ffed67f46c21fa9af3ad
-  data.tar.gz: ead77e379ad1c18641ca8d0457214af393beeee60fe4e5558c69d601f6f269628ce2830b6a35a7fe66e461b88fbebad33dd9bb8b767324030294e2a8f7164d8d
+  metadata.gz: 1885d4f814023905f76105f0edce9155024478408be851a4f6869e537400e924e03d34196e03b428803c274b5fbf7e9bf2d93f4548782aa6d3015063c7ed7883
+  data.tar.gz: 97d22f6b0320a089a3584e76c0baa245811861776e7337e913961cd64cfe0770131493d7de7e1355a62d6339d47d0b1f3ad32dd89084f31c69a61fcfab9f3148

data/lib/parallel/serializer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'openssl'
+require 'securerandom'
+
+module Parallel
+  # Pluggable wire serializers. Each must respond to `dump(data, io)` /
+  # `load(io)` (used directly by Worker) and `dump(data)` / `load(string)`
+  # (used by wrappers like Hmac).
+  module Serializer
+    # Raw Marshal. Fast but trusts anything written to the pipe — a same-UID
+    # attacker that reopens /proc/<pid>/fd/<n> can inject Marshal gadgets (RCE).
+    Marshal = ::Marshal
+
+    # Wraps any inner serializer with a length-prefixed HMAC-SHA256 frame keyed
+    # on a per-worker secret generated before fork. Forged frames from a
+    # pipe-injector fail verification.
+    class Hmac
+      LENGTH_FORMAT = 'N' # 32-bit big-endian unsigned int
+      LENGTH_BYTES = 4
+      MAC_BYTES = 32 # SHA256
+
+      def initialize(inner: Marshal, secret: SecureRandom.bytes(32))
+        @inner = inner
+        @secret = secret
+      end
+
+      def dump(data, io)
+        payload = @inner.dump(data)
+        mac = OpenSSL::HMAC.digest('SHA256', @secret, payload)
+        io.write([payload.bytesize].pack(LENGTH_FORMAT), mac, payload)
+      end
+
+      def load(io)
+        # nil at frame boundary = clean EOF (worker died / pipe closed between messages)
+        header = io.read(LENGTH_BYTES) || raise(EOFError) # eof stops worker
+        raise SecurityError, "truncated frame header" if header.bytesize != LENGTH_BYTES
+
+        length = header.unpack1(LENGTH_FORMAT)
+        mac = io.read(MAC_BYTES)
+        raise SecurityError, "truncated frame mac" if mac.nil? || mac.bytesize != MAC_BYTES
+
+        payload = io.read(length)
+        raise SecurityError, "truncated frame payload" if payload.nil? || payload.bytesize != length
+
+        expected = OpenSSL::HMAC.digest('SHA256', @secret, payload)
+        raise SecurityError, "HMAC mismatch on worker pipe" unless OpenSSL.fixed_length_secure_compare(mac, expected)
+
+        @inner.load(payload)
+      end
+    end
+  end
+end

data/lib/parallel/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Parallel
-  VERSION = Version = '1.27.0' # rubocop:disable Naming/ConstantName
+  VERSION = Version = '2.1.0' # rubocop:disable Naming/ConstantName
 end

data/lib/parallel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'rbconfig'
 require 'parallel/version'
+require 'parallel/serializer'
 
 module Parallel
   Stop = Object.new.freeze
@@ -15,6 +16,17 @@ module Parallel
       super()
       @value = value
     end
+
+    # marshal_dump that is used for ruby exceptions
+    # avoid dumping the cause since nobody needs that and it can include undumpable exceptions
+    def _dump(_depth)
+      Marshal.dump(@value)
+    end
+
+    # marshal_load that is used for ruby exceptions
+    def self._load(data)
+      new(Marshal.load(data))
+    end
   end
 
   class Kill < Break
@@ -52,10 +64,11 @@ module Parallel
     attr_reader :pid, :read, :write
     attr_accessor :thread
 
-    def initialize(read, write, pid)
+    def initialize(read, write, pid, serializer)
       @read = read
       @write = write
       @pid = pid
+      @serializer = serializer
     end
 
     def stop
@@ -72,13 +85,13 @@ module Parallel
 
     def work(data)
       begin
-        Marshal.dump(data, write)
+        @serializer.dump(data, write)
       rescue Errno::EPIPE
         raise DeadWorker
       end
 
       result = begin
-        Marshal.load(read)
+        @serializer.load(read)
       rescue EOFError
         raise DeadWorker
       end
@@ -255,7 +268,7 @@ module Parallel
 
       if options[:in_processes] && options[:in_threads]
         raise ArgumentError, "Please specify only one of `in_processes` or `in_threads`."
-      elsif RUBY_PLATFORM =~ (/java/) && !options[:in_processes]
+      elsif RUBY_PLATFORM.include?('java') && !options[:in_processes]
         method = :in_threads
         size = options[method] || processor_count
       elsif options[:in_threads]
@@ -460,62 +473,86 @@ module Parallel
         raise ArgumentError, "pass the code you want to execute as `ractor: [ClassName, :method_name]`"
       end
 
+      use_port = defined?(Ractor::Port)
+
       # build
-      ractors = Array.new(options.fetch(:count)) do
-        Ractor.new do
-          loop do
-            got = receive
-            (klass, method_name), item, index = got
-            break if index == :break
-            begin
-              Ractor.yield [nil, klass.send(method_name, item), item, index]
-            rescue StandardError => e
-              Ractor.yield [e, nil, item, index]
-            end
-          end
-        end
+      ports = {} # port (ruby 4+) or ractor (ruby 3) => ractor
+      options.fetch(:count).times do
+        port, ractor = ractor_build(use_port)
+        ports[port] = ractor
       end
 
       # start
-      ractors.dup.each do |ractor|
-        if (set = job_factory.next)
-          item, index = set
+      ports.dup.each do |port, ractor|
+        if (job = job_factory.next)
+          item, index = job
           instrument_start item, index, options
           ractor.send [callback, item, index]
-        else
-          ractor.send([[nil, nil], nil, :break]) # stop the ractor
-          ractors.delete ractor
+        else # not enough work, `receive` would hang
+          ractor_stop ractor
+          ports.delete port
         end
       end
 
-      # replace with new items
-      while (set = job_factory.next)
-        item_next, index_next = set
-        done, (exception, result, item, index) = Ractor.select(*ractors)
+      # receive result and send new items to done ractors
+      while (job = job_factory.next)
+        # receive result
+        done_port, (exception, result, item_prev, index_prev) = Ractor.select(*ports.keys)
+        done_ractor = ports[done_port]
         if exception
-          ractors.delete done
+          ports.delete done_port
           break
         end
-        instrument_finish item, index, result, options
-        results_mutex.synchronize { results[index] = (options[:preserve_results] == false ? nil : result) }
+        ractor_result item_prev, index_prev, result, results, results_mutex, options
 
+        # send new
+        item_next, index_next = job
         instrument_start item_next, index_next, options
-        done.send([callback, item_next, index_next])
+        done_ractor.send([callback, item_next, index_next])
       end
 
       # finish
-      ractors.each do |ractor|
-        (new_exception, result, item, index) = ractor.take
+      ports.each do |port, ractor|
+        (new_exception, result, item, index) = use_port ? port.receive : ractor.take
         exception ||= new_exception
         next if new_exception
-        instrument_finish item, index, result, options
-        results_mutex.synchronize { results[index] = (options[:preserve_results] == false ? nil : result) }
-        ractor.send([[nil, nil], nil, :break]) # stop the ractor
+        ractor_result item, index, result, results, results_mutex, options
+        ractor_stop ractor
       end
 
       exception || results
     end
 
+    def ractor_build(use_port)
+      args = use_port ? [Ractor::Port.new] : []
+      ractor = Ractor.new(*args) do |port|
+        loop do
+          (klass, method_name), item, index = receive
+          break if index == :break
+          begin
+            result = [nil, klass.send(method_name, item), item, index]
+          rescue StandardError => e
+            result = [e, nil, item, index]
+          end
+          if port
+            port.send result
+          else
+            Ractor.yield result
+          end
+        end
+      end
+      [use_port ? args.first : ractor, ractor]
+    end
+
+    def ractor_result(item, index, result, results, results_mutex, options)
+      instrument_finish item, index, result, options
+      results_mutex.synchronize { results[index] = (options[:preserve_results] == false ? nil : result) }
+    end
+
+    def ractor_stop(ractor)
+      ractor.send([[nil, nil], nil, :break])
+    end
+
     def work_in_processes(job_factory, options, &blk)
       workers = create_workers(job_factory, options, &blk)
       results = []
@@ -587,6 +624,7 @@ module Parallel
     def worker(job_factory, options, &block)
       child_read, parent_write = IO.pipe
       parent_read, child_write = IO.pipe
+      options[:serializer] ||= Serializer::Marshal
 
       pid = Process.fork do
         self.worker_number = options[:worker_number]
@@ -607,12 +645,13 @@ module Parallel
       child_read.close
       child_write.close
 
-      Worker.new(parent_read, parent_write, pid)
+      Worker.new(parent_read, parent_write, pid, options[:serializer])
     end
 
     def process_incoming_jobs(read, write, job_factory, options, &block)
+      serializer = options.fetch(:serializer)
       until read.eof?
-        data = Marshal.load(read)
+        data = serializer.load(read)
         item, index = job_factory.unpack(data)
 
         result =
@@ -621,12 +660,12 @@ module Parallel
           # https://github.com/rspec/rspec-support/blob/673133cdd13b17077b3d88ece8d7380821f8d7dc/lib/rspec/support.rb#L132-L140
           rescue NoMemoryError, SignalException, Interrupt, SystemExit # rubocop:disable Lint/ShadowedException
             raise $!
-          rescue Exception # # rubocop:disable Lint/RescueException
+          rescue Exception # rubocop:disable Lint/RescueException
             ExceptionWrapper.new($!)
           end
 
         begin
-          Marshal.dump(result, write)
+          serializer.dump(result, write)
         rescue Errno::EPIPE
           return # parent thread already dead
         end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: parallel
 version: !ruby/object:Gem::Version
-  version: 1.27.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Michael Grosser
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 email: michael@grosser.it
 executables: []
@@ -16,15 +16,18 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE.txt
 - lib/parallel.rb
+- lib/parallel/serializer.rb
 - lib/parallel/version.rb
 homepage: https://github.com/grosser/parallel
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/grosser/parallel/issues
-  documentation_uri: https://github.com/grosser/parallel/blob/v1.27.0/Readme.md
-  source_code_uri: https://github.com/grosser/parallel/tree/v1.27.0
+  documentation_uri: https://github.com/grosser/parallel/blob/v2.1.0/Readme.md
+  source_code_uri: https://github.com/grosser/parallel/tree/v2.1.0
   wiki_uri: https://github.com/grosser/parallel/wiki
+  changelog_uri: https://github.com/grosser/parallel/blob/v2.1.0/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -32,14 +35,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Run any kind of code in parallel processes
 test_files: []