cohere-transcribe 0.1.1 → 0.1.2

data/lib/cohere/transcribe/runtime/resources.rb

@@ -12,6 +12,47 @@ module Cohere
       class ModelResources
         OWNER_GUARD = Monitor.new
 
+        # The global owner record and the ObjectSpace finalizer retain this
+        # state, never the ModelResources instance itself. It also lets a new
+        # owner synchronously evict a collected predecessor before loading.
+        class SessionOwnership
+          def initialize
+            @mutex = Mutex.new
+            @session = nil
+          end
+
+          def session
+            @mutex.synchronize { @session }
+          end
+
+          def install(session)
+            @mutex.synchronize do
+              raise TranscriptionRuntimeError, "ASR session ownership is already installed" if @session
+
+              @session = session
+            end
+          end
+
+          def close
+            session = @mutex.synchronize do
+              current = @session
+              @session = nil
+              current
+            end
+            return unless session
+
+            session.close
+            nil
+          end
+
+          def finalize
+            close
+          rescue Exception # rubocop:disable Lint/RescueException -- finalizers must not escape during GC or shutdown
+            nil
+          end
+        end
+        private_constant :SessionOwnership
+
         class << self
           def evict_current_asr_owner
             OWNER_GUARD.synchronize do
@@ -33,16 +74,43 @@ module Cohere
 
             reference.__getobj__
           rescue WeakRef::RefError
-            @owner_reference = nil
+            cleanup_abandoned_owner_locked
             nil
           end
 
           def claim_locked(owner)
             @owner_reference = WeakRef.new(owner)
+            @owner_ownership = owner.send(:asr_ownership)
           end
 
           def release_locked(owner)
-            @owner_reference = nil if current_owner_locked.equal?(owner)
+            return unless @owner_ownership.equal?(owner.send(:asr_ownership))
+
+            @owner_reference = nil
+            @owner_ownership = nil
+          end
+
+          def cleanup_abandoned_owner_locked
+            ownership = @owner_ownership
+            @owner_reference = nil
+            @owner_ownership = nil
+            ownership&.close
+          end
+
+          def finalizer_for(ownership)
+            proc { |_object_id| finalize_ownership(ownership) }
+          end
+
+          def finalize_ownership(ownership)
+            OWNER_GUARD.synchronize do
+              if @owner_ownership.equal?(ownership)
+                @owner_reference = nil
+                @owner_ownership = nil
+              end
+              ownership.finalize
+            end
+          rescue Exception # rubocop:disable Lint/RescueException -- finalizers must not escape during GC or shutdown
+            nil
           end
         end
 
@@ -50,9 +118,13 @@ module Cohere
 
         def initialize
           @asr_key = nil
-          @asr_session = nil
+          @asr_ownership = SessionOwnership.new
           @batch_controller = nil
           @closed = false
+          ObjectSpace.define_finalizer(
+            self,
+            self.class.send(:finalizer_for, @asr_ownership)
+          )
         end
 
         # Returns [session, loaded]. A key change evicts this instance's prior
@@ -62,47 +134,62 @@ module Cohere
 
           self.class::OWNER_GUARD.synchronize do
             ensure_open!
-            evict_asr_locked if @asr_session && @asr_key != key
+            owned_key = immutable_key(key)
+            evict_asr_locked if @asr_ownership.session && @asr_key != owned_key
 
             owner = self.class.send(:current_owner_locked)
             owner.send(:evict_asr_locked) if owner && !owner.equal?(self)
             self.class.send(:claim_locked, self)
 
             loaded = false
-            unless @asr_session
+            unless @asr_ownership.session
               installed = false
+              session = nil
               begin
                 session = yield
                 raise TranscriptionRuntimeError, "ASR loader returned no native session" if session.nil?
 
-                @asr_session = session
-                @asr_key = immutable_key(key)
-                @batch_controller = nil
-                loaded = true
-                installed = true
+                Thread.handle_interrupt(Exception => :never) do
+                  @asr_ownership.install(session)
+                  @asr_key = owned_key
+                  @batch_controller = nil
+                  loaded = true
+                  installed = true
+                end
+              rescue Exception # rubocop:disable Lint/RescueException -- roll back asynchronous loader interruption
+                begin
+                  if @asr_ownership.session.equal?(session)
+                    evict_asr_locked
+                  else
+                    session&.close
+                  end
+                rescue Exception # rubocop:disable Lint/RescueException -- preserve the loader failure
+                  nil
+                end
+                raise
               ensure
                 self.class.send(:release_locked, self) unless installed
               end
             end
-            [@asr_session, loaded].freeze
+            [@asr_ownership.session, loaded].freeze
           end
         end
 
         def install_batch_controller(controller)
           self.class::OWNER_GUARD.synchronize do
             ensure_open!
-            raise TranscriptionRuntimeError, "Cannot install an ASR controller before acquiring ASR" unless @asr_session
+            raise TranscriptionRuntimeError, "Cannot install an ASR controller before acquiring ASR" unless @asr_ownership.session
 
             @batch_controller ||= controller
           end
         end
 
         def asr_session
-          self.class::OWNER_GUARD.synchronize { @asr_session }
+          self.class::OWNER_GUARD.synchronize { @asr_ownership.session }
         end
 
         def asr?
-          self.class::OWNER_GUARD.synchronize { !@asr_session.nil? }
+          self.class::OWNER_GUARD.synchronize { !@asr_ownership.session.nil? }
         end
         alias has_asr? asr?
 
@@ -123,6 +210,7 @@ module Cohere
 
             evict_asr_locked
             @closed = true
+            ObjectSpace.undefine_finalizer(self)
           end
           nil
         end
@@ -133,17 +221,17 @@ module Cohere
 
         private
 
+        attr_reader :asr_ownership
+
         def ensure_open!
           raise TranscriberClosedError, "Model resources have been closed" if @closed
         end
 
         def evict_asr_locked
           self.class.send(:release_locked, self)
-          session = @asr_session
-          @asr_session = nil
           @asr_key = nil
           @batch_controller = nil
-          session&.close
+          @asr_ownership.close
           nil
         end
 

data/lib/cohere/transcribe/state/io.rb

@@ -63,7 +63,10 @@ module Cohere
       # is performed with the POSIX *at family against that descriptor.
       class BoundDirectory
         AT_FUNCTION_SIGNATURES = {
-          openat: [[Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_INT], Fiddle::TYPE_INT],
+          openat: [
+            [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VARIADIC],
+            Fiddle::TYPE_INT
+          ],
           renameat: [
             [Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_VOIDP],
             Fiddle::TYPE_INT
@@ -294,7 +297,14 @@ module Cohere
 
         def open_entry(name, flags, permissions, mode:)
           validate_entry_name!(name)
-          file_descriptor = call_at!(:openat, descriptor, name, flags, permissions)
+          file_descriptor = call_at!(
+            :openat,
+            descriptor,
+            name,
+            flags,
+            Fiddle::TYPE_INT,
+            permissions
+          )
           handle = File.new(file_descriptor, mode, autoclose: true)
           file_descriptor = nil
           handle.close_on_exec = true

data/lib/cohere/transcribe/state/manifest.rb

@@ -105,18 +105,21 @@ module Cohere
           return "state marker path for #{format} does not match" unless record.is_a?(Hash) && record["name"] == path.basename.to_s
 
           begin
-            size, sha256 = if directory_binding
-                             bound_output_record(
-                               path,
-                               directory_binding: directory_binding,
-                               guard_bindings: guard_bindings
-                             )
-                           else
-                             stat = path.lstat
-                             return "#{format} output is missing or not regular" unless stat.file? && !stat.symlink?
-
-                             [stat.size, Digest::SHA256.file(path).hexdigest]
-                           end
+            output_record = if directory_binding
+                              bound_output_record(
+                                path,
+                                directory_binding: directory_binding,
+                                guard_bindings: guard_bindings
+                              )
+                            else
+                              stat = path.lstat
+                              return "#{format} output is missing or not regular" unless stat.file? && !stat.symlink?
+
+                              [stat.size, Digest::SHA256.file(path).hexdigest]
+                            end
+            return "#{format} output changed or is not regular" unless output_record
+
+            size, sha256 = output_record
             return "#{format} output does not match its state marker" if record["size"] != size || record["sha256"] != sha256
           rescue Errno::ENOENT
             return "#{format} output is missing or not regular"
@@ -133,14 +136,25 @@ module Cohere
         ) do |bound, basename|
           bound.verify!
           handle = nil
-          Thread.handle_interrupt(DEFERRED_PUBLICATION_EXCEPTIONS) do
-            handle = bound.open_regular(basename)
+          begin
+            Thread.handle_interrupt(DEFERRED_PUBLICATION_EXCEPTIONS) do
+              handle = bound.open_regular(basename)
+            end
+          rescue TranscriptionRuntimeError
+            bound.verify!
+            return nil
           end
           opened = handle.stat
           digest = Digest::SHA256.new
           digest << handle.read(1024 * 1024) until handle.eof?
-          unless bound.same_regular_entry?(basename, opened)
-            raise TranscriptionRuntimeError, "Output changed while it was being verified: #{path}"
+          unchanged = begin
+            bound.same_regular_entry?(basename, opened)
+          rescue TranscriptionRuntimeError
+            false
+          end
+          unless unchanged
+            bound.verify!
+            return nil
           end
 
           bound.verify!

data/lib/cohere/transcribe/version.rb

@@ -2,6 +2,6 @@
 
 module Cohere
   module Transcribe
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cohere-transcribe
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ali Hamdi Ali Fadel