hakuban 0.7.0 → 0.8.1

data/lib/hakuban/object_state.rb

@@ -9,6 +9,7 @@ module Hakuban
 		class WrongFormatError < Exception; end
 
 		def initialize(data, version: nil, format: nil, synchronized_us_ago: 0, &block)
+			super()
 			if version.nil?
 				timestamp = Time.new
 				version = [0, timestamp.to_i, timestamp.nsec]
@@ -18,14 +19,19 @@ module Hakuban
 			@synchronized_us_ago = synchronized_us_ago
 			@data = data
 			@pointer = false
-			@mutex = Mutex.new
-			self.do_and_drop_or_return(&block)
+			Thread.handle_interrupt(Object => :never) {
+				self.do_and_drop_or_return(&block)
+			}
+		end
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
 		end
 
 
+
 		def with_pointer
-			@mutex.synchronize {
-				raise PointerAlreadyDropped  if dropped?
+			@pointer_mutex.synchronize {
 				if @pointer == false
 					Hakuban::hakuban_initialize
 					version_pointer = ::FFI::MemoryPointer.new(:int64, @version.size)
@@ -41,13 +47,6 @@ module Hakuban
 			}
 		end
 
-
-		private_class_method def self.from_ffi_pointer(pointer)
-			new_instance = allocate
-			new_instance.send(:initialize_pointer, pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
-			new_instance
-		end
-
 		def data
 			return @data  if defined? @data
 			array = with_pointer { |pointer| FFI::hakuban_object_state_data(pointer) }
@@ -94,7 +93,7 @@ module Hakuban
 		end
 
 		def json_serialize
-			ObjectState.new(JSON.dump(data), version: version, format: format+["JSON"], synchronized_us_ago: synchronized_us_ago)
+			ObjectState.new(data.to_json, version: version, format: format+["JSON"], synchronized_us_ago: synchronized_us_ago)
 		end
 
 		def inspect
@@ -102,5 +101,5 @@ module Hakuban
 		end
 
 	end
-	
-end
+
+end

data/lib/hakuban/object_state_sink.rb

@@ -8,54 +8,46 @@ module Hakuban
 
 		private_class_method :new
 
-		def initialize(pointer)
-			initialize_pointer(pointer, :hakuban_object_state_sink_drop, nil)
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_sink_drop, nil)
 		end
 
 
 		include Stream
 
 
-		def next(&block)
-			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_state_sink_next(pointer) }.unwrap
-			ObjectStateSinkParams.send(:new, pointer).do_and_drop_or_return(&block)
-		rescue FFIObject::PointerAlreadyDropped
-		end
-
-
-		def current(&block)
-			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_state_sink_current(pointer) }.unwrap
-			ObjectStateSinkParams.send(:new, pointer).do_and_drop_or_return(&block)
-		rescue FFIObject::PointerAlreadyDropped
+		def next(drop_at_the_end_of_block=true, &block)
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_state_sink_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectStateSinkParams, pointer) },
+				&block
+			)
 		end
 
 
 		def send(object_state)
-			FFI::FFIFutureReturningNothing.create_and_await(self)  { |pointer| 
-				object_state.with_pointer { |object_state_pointer| FFI::hakuban_object_state_sink_send(pointer, object_state_pointer) }
-			}.unwrap
-		rescue FFIObject::PointerAlreadyDropped
+			process_item(
+				lambda { |pointer| object_state.with_pointer { |object_state_pointer| FFI::hakuban_object_state_sink_send(pointer, object_state_pointer) } },
+				lambda { |_pointer| nil },
+				&lambda {}
+			)
 		end
 
 
 		def descriptor
-			Hakuban::ObjectDescriptor.send(:from_ffi_pointer, with_pointer { |pointer| FFI::hakuban_object_state_sink_descriptor(pointer) }) 
+			Hakuban::FFIObject.from_ffi_pointer(Hakuban::ObjectDescriptor, with_pointer { |pointer| FFI::hakuban_object_state_sink_descriptor(pointer) })
 		end
 		
 
-		def desynchronize
-			with_pointer { |pointer| FFI::hakuban_object_state_sink_desynchronize(pointer) }
-		rescue FFIObject::PointerAlreadyDropped
-		end
-
 	end
 
 	class ObjectStateSinkParams < FFIObject
 
 		private_class_method :new
 
-		def initialize(pointer)
-			initialize_pointer(pointer, :hakuban_object_state_sink_params_drop, :hakuban_object_state_sink_params_clone)
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_sink_params_drop, :hakuban_object_state_sink_params_clone)
 		end
 
 	end

data/lib/hakuban/object_state_stream.rb

@@ -1,37 +1,37 @@
+require 'hakuban/ffi.rb'
 require 'hakuban/ffi-object.rb'
 require 'hakuban/stream.rb'
-
+require 'hakuban/refinements.rb'
 
 module Hakuban
 
+
 	class ObjectStateStream < FFIObject
 
 		private_class_method :new
 		
-		def initialize(pointer)
-			initialize_pointer(pointer, :hakuban_object_state_stream_drop, nil)
+
+		def initialize_from_ffi_pointer(pointer)
+			super(pointer, :hakuban_object_state_stream_drop, nil)
 		end
 
 
+
 		include Stream
 
 
+		
 		def next(&block)
-			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_state_stream_next(pointer) }.unwrap
-			ObjectState.send(:from_ffi_pointer, pointer).do_and_drop_or_return(&block)
-		rescue FFIObject::PointerAlreadyDropped	
+			process_item(
+				lambda { |pointer| FFI::hakuban_object_state_stream_next(pointer) },
+				lambda { |pointer| FFIObject::from_ffi_pointer(ObjectState, pointer) },
+				&block
+			)
 		end
-
-
-		def current(&block)
-			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_state_stream_current(pointer) }.unwrap
-			ObjectState.send(:from_ffi_pointer, pointer).do_and_drop_or_return(&block)
-		rescue FFIObject::PointerAlreadyDropped	
-		end
-
 		
+
 		def descriptor
-			Hakuban::ObjectDescriptor.send(:from_ffi_pointer, with_pointer { |pointer| FFI::hakuban_object_state_stream_descriptor(pointer) })
+			Hakuban::FFIObject.from_ffi_pointer(Hakuban::ObjectDescriptor, with_pointer { |pointer| FFI::hakuban_object_state_stream_descriptor(pointer) })
 		end
 		
 	end

data/lib/hakuban/refinements.rb

@@ -0,0 +1,23 @@
+module ThreadExt
+
+	refine Thread do
+
+		def join_with_warning(timeout=60)
+			loop {
+				self.join(60)
+				return self.value  if !self.status
+				$stderr.puts "Thread doesn't want to die: \n"+item_thread.backtrace.inspect+"\nat:\n"+caller.join("\n")
+			}
+		end
+
+
+		def Thread.process_interrupts
+			Thread.handle_interrupt(Object => :immediate) {
+				Thread.pass
+			}
+			nil
+		end
+
+	end 
+
+end

data/lib/hakuban/stream.rb

@@ -1,119 +1,189 @@
+require 'hakuban/refinements'
+
+#TODO: bring back Async variants
 
 module Hakuban
 
 	module Stream
 
-		def each(*args,**kwargs,&block)
-			StreamEnumerator.new(self,false,false,false,args,kwargs).call_or_return(&block)
+		using ThreadExt
+
+		class NextItemInterrupt < Exception
+			def ==(other)
+				other.object_id == self.object_id
+			end
 		end
 
-		class KilledOnNext < Exception; end
-		
-		#TODO: meh
-		class StreamEnumerator
 
-			def initialize(stream, without_implicit_drop, async, kill_on_next, args, kwargs)
-				@stream, @without_implicit_drop, @async, @kill_on_next, @args, @kwargs = stream, without_implicit_drop, async, kill_on_next, args, kwargs
-			end
+		# next may be called in CLI context, so, every return branch should process interrupts explicitly
+		private def process_item(future_constructor, item_constructor, &block)
+			Thread.handle_interrupt(Object => :never) do
+				future_pointer = begin
+					with_pointer(&future_constructor)
+				rescue FFIObject::PointerAlreadyDropped
+					Thread.process_interrupts
+					return nil
+				end
+				
+				result, error = Hakuban::FFI::FFIFuture.await(future_pointer)
+				item = if pointer = result.unwrap
+					item_constructor.call(pointer)
+				end
 
-			def async(*args,**kwargs,&block)
-				StreamEnumerator.new(@stream, @without_implicit_drop, :async, @kill_on_next, @args+args, @kwargs.merge(kwargs)).call_or_return(&block)
-			end
+				raise error  if error
+				return item   if block.nil?
 
-			def thread(*args,**kwargs,&block)
-				StreamEnumerator.new(@stream, @without_implicit_drop, :thread, @kill_on_next, @args+args, @kwargs.merge(kwargs)).call_or_return(&block)
-			end
-			
-			def without_implicit_drop(*args,**kwargs,&block)
-				StreamEnumerator.new(@stream, true, @async, @kill_on_next, @args+args, @kwargs.merge(kwargs)).call_or_return(&block)
+				if item.nil?
+					Thread.process_interrupts
+					nil
+				else
+					Thread.handle_interrupt(Object => :immediate) {
+						block.call(item)
+					}
+				end
+
+			ensure
+				item.drop  if !!block and !!item
 			end
+		end
 
-			def kill_on_next(*args,**kwargs,&block)
-				StreamEnumerator.new(@stream, @without_implicit_drop, @async, true, @args+args, @kwargs.merge(kwargs)).call_or_return(&block)
+		def each(*args, **kwargs, &block)
+			for_each(*args, **kwargs, &block)
+		end
+
+		def for_each(*args, **kwargs, &block)
+			if kwargs[:interrupt_on_next]
+				for_each_till_next(*args, **kwargs, &block)
+			else
+				while self.next { |new_item| sync_call(new_item, args, kwargs, block); true }; end
 			end
+		end
 
-			def call_or_return(&block)
-				if block
-					Thread.handle_interrupt(Object => :never) {
-						begin
-							to_kill = nil
-							Thread.handle_interrupt(Object => :immediate) {
-								while new_item = @stream.next
-									case @async
-									when false
-										sync_call(new_item, block)
-									when :async
-										if @kill_on_next
-											if to_kill
-												to_kill.stop
-												to_kill.wait
-											end
-										end
-										to_kill = Async(new_item) { |_task, item|
-											sync_call(item, block)
-										}						
-									when :thread
-										if @kill_on_next
-											if to_kill
-												to_kill.raise KilledOnNext.new
-												to_kill.value 
-											end
-										end
-										to_kill = Thread.new(new_item) { |item|
-											sync_call(item, block)
-										}						
-									end
-								end
 
-								case @async
-								when false
-								when :async
-									if @kill_on_next
-										if to_kill
-											to_kill.stop
-											to_kill.wait
-										end
-									end
-								when :thread
-									if @kill_on_next
-										if to_kill
-											to_kill.raise KilledOnNext.new
-											to_kill.value 
-										end
+		def for_each_till_next(*args, **kwargs, &block)
+			for_each_in_thread(*args,**kwargs.merge(kill_previous_on_next: true), &block)			
+		end
+
+
+		def for_each_concurrent(*args, **kwargs, &block)
+			for_each_in_thread(*args, **kwargs, &block)
+		end
+
+
+		def for_each_in_thread(*args, **kwargs, &block)			
+			Thread.handle_interrupt(Object => :never) {
+
+				# we poll the stream in a separate thread because we sometimes want to interrupt the polling thread from an item-handling thread, and, without the wrapper-thread, we could end up raising exception in a random place of code, if Async is being used. maybe?
+				stream_polling_thread = Thread.new {
+					begin
+						item_threads = ObjectSpace::WeakMap.new
+						exception_to_rescue = NextItemInterrupt.new
+
+						while new_item = self.next
+							if kwargs[:kill_previous_on_next]
+								item_threads.keys.each { |item_thread| 
+									item_thread.raise(exception_to_rescue)
+									item_thread.join
+								}
+							end
+
+							item_threads[Thread.new(new_item, Thread.current) do |item, parent_thread|
+								sync_call(item, args, kwargs, block)
+							rescue Object => error
+								if error != exception_to_rescue
+									if kwargs[:propagate_exceptions].nil? or kwargs[:propagate_exceptions]
+										parent_thread.raise(error)
+									else
+										raise
 									end
 								end
-							}
-						ensure
-							#TODO: should we kill still-running sub-tasks here, or await? or maybe kill on exception, and await otherwise?
+							ensure
+								item_threads.delete Thread.current
+							end] = true
 						end
-					}
-				else
-					self
-				end
-			end
 
-			private def sync_call(item, block)
-				if @without_implicit_drop
-					begin
-						block.call(item, *@args, **@kwargs)
-					rescue KilledOnNext
-					end
-				else
-					Thread.handle_interrupt(Object => :never) {
-						begin
-							Thread.handle_interrupt(Object => :immediate) {
-								block.call(item, *@args, **@kwargs)
+						if kwargs[:kill_previous_on_next]
+							item_threads.keys.each { |item_thread| 
+								item_thread.raise(exception_to_rescue)
+								item_thread.join
 							}
-						rescue KilledOnNext
-						ensure
-							item.drop
 						end
+
+						Thread.handle_interrupt(Object => :immediate) {
+							item_threads.keys.each { |item_thread|
+								item_thread.join
+							}
+						}
+
+						nil
+					rescue Object => error
+						exception_to_rescue = error
+						item_threads.keys.each { |item_thread| item_thread.raise(error) }
+						error
+					ensure
+						item_threads.keys.each { |item_thread|
+							begin
+								item_thread.join_with_warning(60)
+							rescue Object => error
+								# it's probably better to not re-raise here, so this one doesn't obscure the original. but lets at least print it out.
+								$stderr.puts "Item thread exception: \n"+error.inspect
+							end
+						}	
+					end
+				}
+				 
+				begin
+					Thread.handle_interrupt(Object => :immediate) {
+						value = stream_polling_thread.join.value
+						raise value  if !value.nil?
 					}
+				rescue Object => error
+					stream_polling_thread.raise(error)
+					raise
+				ensure
+					begin
+						stream_polling_thread.join_with_warning(60)
+					rescue Object => error
+						# it's probably better to not re-raise here, so this one doesn't obscure the original. but lets at least print it out.
+						$stderr.puts "Item thread exception: \n"+error.inspect
+					end
 				end
-			end
 
+			}
+		end
+
+
+		## blocks can't be sanely passed to ractors :(
+		# def for_each_in_ractor(*args, **kwargs, &block)
+		# 	Thread.handle_interrupt(Object => :never) {
+		# 		begin
+		# 			Thread.handle_interrupt(Object => :immediate) {
+		# 				while new_item = self.next
+		# 					Ractor.new(new_item, args, kwargs, runner ) { |item, args, kwargs, runner|
+		# 						sync_call(item, args, kwargs, runner)
+		# 					}
+		# 				end
+		# 			}
+		# 		ensure
+		# 			#TODO: should we kill still-running sub-tasks here, or await? or maybe kill on exception, and await otherwise?
+		# 		end
+		# 	}
+		# end
+				
+
+		private def sync_call(item, args, kwargs, block)
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					Thread.handle_interrupt(Object => :immediate) {
+						block.call(item, *args, **kwargs)
+					}
+				ensure
+					item.drop
+				end
+			}
 		end
 
+
 	end
 
 end

data/lib/hakuban/tokio-websocket-connector.rb

@@ -21,12 +21,19 @@ module Hakuban
 
 	class WebsocketConnector < FFIObject
 
-		def initialize(local_exchange, url, &block)
-			pointer = local_exchange.with_pointer { |local_exchange_pointer| FFI::hakuban_tokio_websocket_connector_new(Tokio.pointer, local_exchange_pointer, url) }.unwrap
-			initialize_pointer(pointer, :hakuban_tokio_websocket_connector_drop, nil)
-			self.do_and_drop_or_return(&block)
+		def initialize(exchange, url, &block)
+			super()
+			Thread.handle_interrupt(Object => :never) {
+				pointer = exchange.with_pointer { |exchange_pointer| FFI::hakuban_tokio_websocket_connector_new(Tokio.pointer, exchange_pointer, url) }.unwrap
+				initialize_pointer(pointer, :hakuban_tokio_websocket_connector_drop, nil)
+				self.do_and_drop_or_return(&block)
+			}
 		end
 
 	end
 
-end
+end
+
+def self.default_name
+	"#{Socket.gethostname}:#{File.basename(caller_locations(0..1)[1].path)}:#{$$}"
+end

data/lib/hakuban/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hakuban
-	VERSION = "0.7.0"
+	VERSION = "0.8.1"
 end

data/lib/hakuban.rb

@@ -11,7 +11,7 @@ end
 
 require_relative 'hakuban/contract.rb'
 require_relative 'hakuban/descriptor.rb'
-require_relative "hakuban/engine"
+require_relative "hakuban/engine.rb"
 require_relative 'hakuban/exchange.rb'
 require_relative 'hakuban/ffi-object.rb'
 require_relative 'hakuban/logger.rb'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hakuban
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-08 00:00:00.000000000 Z
+date: 2025-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,75 +16,75 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.13'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.22'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '4.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '4.10'
 description: Ruby binding for convenient data-object sharing library - Hakuban.
 email:
 - maciej.blomberg@mikoton.com
 executables:
-- hakuban-observer
+- hakuban-observe
 - hakuban-engine
 extensions: []
 extra_rdoc_files: []
@@ -93,7 +93,7 @@ files:
 - README.md
 - Rakefile
 - bin/hakuban-engine
-- bin/hakuban-observer
+- bin/hakuban-observe
 - lib/hakuban.rb
 - lib/hakuban/contract.rb
 - lib/hakuban/descriptor.rb
@@ -105,6 +105,7 @@ files:
 - lib/hakuban/object_state.rb
 - lib/hakuban/object_state_sink.rb
 - lib/hakuban/object_state_stream.rb
+- lib/hakuban/refinements.rb
 - lib/hakuban/stream.rb
 - lib/hakuban/tokio-websocket-connector.rb
 - lib/hakuban/version.rb
@@ -127,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Ruby binding for Hakuban library