hakuban 0.6.5 → 0.8.0

data/lib/hakuban/stream.rb

@@ -0,0 +1,189 @@
+require 'hakuban/refinements'
+
+#TODO: bring back Async variants
+
+module Hakuban
+
+	module Stream
+
+		using ThreadExt
+
+		class NextItemInterrupt < Exception
+			def ==(other)
+				other.object_id == self.object_id
+			end
+		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
+
+				raise error  if error
+				return item   if block.nil?
+
+				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 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 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
+								item_threads.delete Thread.current
+							end] = true
+						end
+
+						if kwargs[:kill_previous_on_next]
+							item_threads.keys.each { |item_thread| 
+								item_thread.raise(exception_to_rescue)
+								item_thread.join
+							}
+						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
+
+
+		## 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

@@ -0,0 +1,39 @@
+require 'hakuban/ffi-object.rb'
+
+module Hakuban
+
+	class Tokio
+
+		@@pointer = nil
+
+		def Tokio.init(workers_count=0)
+			Hakuban::hakuban_initialize
+			@@pointer ||= FFI::hakuban_tokio_init_multi_thread(0)
+		end
+
+		def Tokio.pointer
+			Tokio.init  if not @@pointer
+			@@pointer
+		end
+
+	end
+
+
+	class WebsocketConnector < FFIObject
+
+		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
+
+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.6.5"
+	VERSION = "0.8.0"
 end

data/lib/hakuban.rb

@@ -1,10 +1,25 @@
 # frozen_string_literal: true
 
-require_relative "hakuban/version"
-require_relative "hakuban/hakuban"
-require_relative "hakuban/engine"
-#require_relative "hakuban/async"
-#require_relative "hakuban/thread"
-
 module Hakuban
+
+	def self.hakuban_initialize
+		require_relative 'hakuban/ffi.rb'
+	end
+
 end
+
+
+require_relative 'hakuban/contract.rb'
+require_relative 'hakuban/descriptor.rb'
+require_relative "hakuban/engine.rb"
+require_relative 'hakuban/exchange.rb'
+require_relative 'hakuban/ffi-object.rb'
+require_relative 'hakuban/logger.rb'
+require_relative 'hakuban/object_state_sink.rb'
+require_relative 'hakuban/object_state_stream.rb'
+require_relative 'hakuban/object_state.rb'
+require_relative 'hakuban/tokio-websocket-connector.rb'
+require_relative "hakuban/version"
+
+
+#TODO: error classes

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hakuban
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.8.0
 platform: ruby
 authors:
 - yunta
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-26 00:00:00.000000000 Z
+date: 2025-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,78 +16,98 @@ 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.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        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-thread-engine
+- hakuban-observe
+- hakuban-engine
 extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- bin/hakuban-observer
-- bin/hakuban-thread-engine
+- bin/hakuban-engine
+- bin/hakuban-observe
 - lib/hakuban.rb
-- lib/hakuban/async.rb
+- lib/hakuban/contract.rb
+- lib/hakuban/descriptor.rb
 - lib/hakuban/engine.rb
-- lib/hakuban/event-queue.rb
+- lib/hakuban/exchange.rb
+- lib/hakuban/ffi-object.rb
 - lib/hakuban/ffi.rb
-- lib/hakuban/hakuban.rb
-- lib/hakuban/manager.rb
-- lib/hakuban/thread.rb
+- lib/hakuban/logger.rb
+- 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
 homepage: https://gitlab.com/yunta/hakuban-ruby
 licenses:
@@ -108,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Ruby binding for Hakuban library

data/bin/hakuban-observer

@@ -1,64 +0,0 @@
-#!/bin/env ruby
-
-require 'slop'
-require 'pp'
-require 'hakuban/thread'
-
-
-OPTIONS = Slop.parse { |o|
-	o.string '-c', '--connect', "Hakuban upstream address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001"
-	o.string '-o', '--object', "Object descriptor"
-	o.array '-t', '--tag', "Tag descriptor(s)"
-	o.bool '-d', '--debug', 'Show debug messages'
-	o.on '-h', '--help' do puts o; exit end
-}
-
-Hakuban.logger_initialize("hakuban=debug")  if OPTIONS.debug?
-hakuban = Hakuban::LocalNode.new(name: OPTIONS["name"])
-connector = Hakuban::WebsocketConnector.new(hakuban, OPTIONS["connect"])
-
-observe_contract = if OPTIONS["object"]
-	json = JSON.load(OPTIONS["object"])
-	tags = OPTIONS["tag"].map { |tag| JSON.load(tag) }
-	hakuban.object(tags, json).observe
-else
-	tag = OPTIONS["tag"].map { |tag| JSON.load(tag) }
-	hakuban.tag(tag[0]).observe
-end		
-
-
-def print_event(descriptor, event, more)
-	if $subsequent 
-		puts ','
-	else
-		$subsequent = true
-	end
-	puts '{'
-	puts '"event": "%s",'%[event]
-	puts '"descriptor_json": %s,'%[JSON.dump(descriptor.json)]
-	puts '"descriptor_tags": [%s],'%[descriptor.tags.map { |tag| JSON.dump(tag.json) }.join(",")]
-	puts more  if more
-	puts '}'
-end
-
-
-puts "["
-
-contract = observe_contract.manage.with_thread { |object|
-	print_event(object.descriptor, "create", nil)
-	while object.next_change
-		print_event(object.descriptor, "change", 
-			if state = object.state
-				[
-					'"version": %s,'%[JSON.dump(state.version)],
-					'"last_sync_ms_ago": %s,'%[JSON.dump(state.synchronized)],
-					'"data": %s,'%[JSON.dump(state.data)],
-				].join("\n")
-			end
-		)
-	end
-	print_event(object.descriptor, "drop", nil)
-}
-
-$stdin.read(1)
-puts "]"

data/lib/hakuban/async.rb

@@ -1,38 +0,0 @@
-require 'hakuban'
-require 'hakuban/manager'
-require 'async'
-
-module Hakuban
-
-	class AsyncObjectManager < ObjectManager
-
-		def async_run
-			Async { yield }
-		end
-
-		def async_join(task)
-			task.wait
-		end
-
-		def async_stop(task)
-			task.stop	
-		end
-
-		def async_filter_out_stop_exception
-			yield
-		rescue Async::Stop
-			nil
-		end
-		
-	end
-
-
-	class ObjectManagerBuilder
-	
-		def with_async(&block)
-			build(AsyncObjectManager, block)
-		end
-		
-	end
-
-end

data/lib/hakuban/event-queue.rb

@@ -1,75 +0,0 @@
-#TODO: rebuild to handle event squashing on rust side
-
-require 'ostruct'
-
-
-module Hakuban
-
-	class Event < OpenStruct; end
-
-	class ObjectDescriptorCallbackEventQueue
-
-		def initialize(pointer)
-			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
-		end
-
-
-		# WARNING: this callback may be run from a separate, non-ruby, thread
-		def callback_register(&callback)
-			ffi_callback = proc { |_userdata, ffi_descriptor, ffi_action|
-				action = Hakuban::action_int_to_symbol(ffi_action)
-				descriptor = ObjectDescriptor.from_ffi(ffi_descriptor)
-				callback.call(descriptor, action)
-			}
-			@callback_pointer = ::FFI::AutoPointer.new(
-				FFI::hakuban_object_descriptor_events_callback_register(@events_pointer, ffi_callback, ::FFI::Pointer::NULL),
-				proc { |ptr| FFI::hakuban_object_descriptor_events_callback_unregister(ptr) }
-			)
-		end
-
-
-		def callback_unregister
-			@callback_pointer.free
-			@callback_pointer = nil
-		end
-
-
-		def drop
-			@events_pointer.free
-			@events_pointer = nil
-		end
-
-	end
-
-
-	class ObjectDescriptorEventQueue
-
-		def initialize(contract)
-			@contract = contract
-			@queue = Queue.new
-			@ffi_callback = proc { |descriptor, action|
-				@queue << Hakuban::Event.new(action: action, descriptor: descriptor)
-			}
-			@ffi_events = @contract.new_callback_event_queue
-			@ffi_events.callback_register(&@ffi_callback)
-		end
-
-
-		#def push(event)
-		#	@queue << event
-		#end
-
-
-		def next_event; next_change; end
-		def next_change
-			@queue.pop
-		end
-		
-
-		def close
-			@queue.close
-		end
-
-	end
-
-end