async-bus 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 354c43b3ef6922366c369eb209cede56b7bbca16d896b718ebfbe222eb7a4d97
-  data.tar.gz: 856c7c3cd32189b912d3115a3c218a1210215d4850391b18b7d0960be0686de9
+  metadata.gz: bcce5759c8ff0eab16a54c2cf8dd48c054dac88bec2705124cc70589563b9fbb
+  data.tar.gz: 63b96c8cc50edf9f357df6ea992cb4f6ec63aa89f5349c9e0d8ff85c97dafc91
 SHA512:
-  metadata.gz: a38c42252effdbadbacd1d15da7d1e76f2632085430e3954668d0cef74b18404462b3c51ed6303598510679707c75d0bdbce7b1cc622a1abd2d70d126e5d457b
-  data.tar.gz: da3e7ccca7be7eb09180aa85d62412393056c36a38aee64b418feaef02dd244367f636c7d6a4bbb4a2a88b3aa993b7ab8447885c2c14b8dda25a47f13725c713
+  metadata.gz: a87a86e44c67ca9e4ca76234e0f844c2bb92d14eaffd52f16104f1b14038d266e3725abc584fe779088256c2cdf34e0bfeb4e29aecddeaa71f2d2835f2ed692a
+  data.tar.gz: c28eb52cc46f0ae4d3dcbd1c3e823174e273dde9e9dd1678d672b2f0d3ba5704fe495c511c07355be0a1215d0ade1e0824ca36e8f27d20a11f42f00711b65290

data/lib/async/bus/client.rb

@@ -1,54 +1,86 @@
 # frozen_string_literal: true
 
-# Copyright, 2020, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# Released under the MIT License.
+# Copyright, 2021-2025, by Samuel Williams.
 
-require_relative 'protocol/connection'
-require 'async/queue'
+require_relative "protocol/connection"
+require "async/queue"
 
 module Async
 	module Bus
 		class Client
-			def initialize(endpoint = nil)
+			def initialize(endpoint = nil, **options)
 				@endpoint = endpoint || Protocol.local_endpoint
-				@queue = Async::Queue.new
+				@options = options
 			end
 			
-			def connect
-				@endpoint.connect do |peer|
-					connection = Protocol::Connection.client(peer)
-					
-					connection_task = Async do
-						connection.run
-					end
-					
-					return yield(connection)
+			# Create a new connection to the server.
+			#
+			# @returns [Protocol::Connection] The new connection.
+			protected def connect!
+				peer = @endpoint.connect
+				return Protocol::Connection.client(peer, **@options)
+			end
+			
+			# Called when a connection is established.
+			# Override this method to perform setup when a connection is established.
+			#
+			# @parameter connection [Protocol::Connection] The established connection.
+			protected def connected!(connection)
+				# Do nothing by default.
+			end
+			
+			# Connect to the server.
+			#
+			# @parameter persist [Boolean] Whether to keep the connection open indefiniely.
+			# @yields {|connection| ...} If a block is given, it will be called with the connection, and the connection will be closed afterwards.
+			# @returns [Protocol::Connection] The connection if no block is given.
+			def connect(parent: Task.current)
+				connection = connect!
+				
+				connection_task = parent.async do
+					connection.run
+				end
+				
+				connected!(connection)
+				
+				return connection unless block_given?
+				
+				begin
+					yield(connection, connection_task)
 				ensure
 					connection_task&.stop
+					connection&.close
 				end
 			end
 			
-			protected
-			
-			def handle(connection, message)
-				# No default implementation.
+			# Run the client in a loop, reconnecting if necessary.
+			#
+			# Automatically reconnects when the connection fails, with random backoff.
+			# This is useful for long-running clients that need to maintain a persistent connection.
+			#
+			# @parameter parent [Async::Task] The parent task to run under.
+			def run(parent: Task.current)
+				parent.async(annotation: "Bus Client", transient: true) do |task|
+					loop do
+						connection = connect!
+						
+						connected_task = task.async do
+							connected!(connection)
+						end
+						
+						connection.run
+					rescue => error
+						Console.error(self, "Connection failed:", exception: error)
+						sleep(rand)
+					ensure
+						# Ensure any tasks that were created during connection are stopped:
+						connected_task&.stop
+						
+						# Close the connection itself:
+						connection&.close
+					end
+				end
 			end
 		end
 	end

data/lib/async/bus/controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module Bus
+		# Base class for controller objects designed to be proxied over Async::Bus.
+		#
+		# Controllers provide an explicit API for remote operations, avoiding the
+		# confusion that comes from proxying generic objects like Array or Hash.
+		#
+		# @example Array Controller
+		#   class ArrayController < Async::Bus::Controller
+		#     def initialize(array)
+		#       @array = array
+		#     end
+		#
+		#     def append(*values)
+		#       @array.concat(values)
+		#       self  # Return self for chaining
+		#     end
+		#
+		#     def get(index)
+		#       @array[index]  # Returns value
+		#     end
+		#
+		#     def size
+		#       @array.size
+		#     end
+		#   end
+		#
+		# @example Server Setup
+		#   server.accept do |connection|
+		#     array = []
+		#     controller = ArrayController.new(array)
+		#     connection.bind(:items, controller)
+		#   end
+		#
+		# @example Client Usage
+		#   client.connect do |connection|
+		#     items = connection[:items]  # Returns proxy to controller
+		#     items.append(1, 2, 3)       # Remote call
+		#     expect(items.size).to be == 3
+		#   end
+		#
+		# Controllers are automatically proxied when serialized if registered
+		# as a reference type in the Wrapper:
+		#
+		#   Wrapper.new(connection, reference_types: [Async::Bus::Controller])
+		#
+		# This allows controller methods to return other controllers and have
+		# them automatically proxied.
+		class Controller
+		end
+	end
+end
+

data/lib/async/bus/protocol/connection.rb

@@ -1,61 +1,77 @@
 # frozen_string_literal: true
 
-# Copyright, 2021, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# Released under the MIT License.
+# Copyright, 2021-2025, by Samuel Williams.
 
-require 'async'
-require 'async/io/unix_endpoint'
+require "async"
+require "io/endpoint/unix_endpoint"
 
-require_relative 'wrapper'
-require_relative 'transaction'
-require_relative 'proxy'
+require_relative "wrapper"
+require_relative "transaction"
+require_relative "proxy"
+require_relative "response"
 
 module Async
 	module Bus
 		module Protocol
 			def self.local_endpoint(path = "bus.ipc")
-				Async::IO::Endpoint.unix(path)
+				::IO::Endpoint.unix(path)
 			end
 			
 			class Connection
-				def self.client(peer)
-					self.new(peer, 1)
+				def self.client(peer, **options)
+					self.new(peer, 1, **options)
 				end
 				
-				def self.server(peer)
-					self.new(peer, 2)
+				def self.server(peer, **options)
+					self.new(peer, 2, **options)
 				end
 				
-				def initialize(peer, id)
+				def initialize(peer, id, wrapper: Wrapper, timeout: nil)
 					@peer = peer
+					@id = id
 					
-					@wrapper = Wrapper.new(self)
+					@wrapper = wrapper.new(self)
 					@unpacker = @wrapper.unpacker(peer)
 					@packer = @wrapper.packer(peer)
 					
+					@timeout = timeout
+					
 					@transactions = {}
-					@id = id
 					
 					@objects = {}
+					@proxies = ::ObjectSpace::WeakMap.new
+					@finalized = ::Thread::Queue.new
+				end
+				
+				# @attribute [Float] The timeout for transactions.
+				attr_accessor :timeout
+				
+				def flush
+					@packer.flush
+				end
+				
+				def write(message)
+					# $stderr.puts "Writing: #{message.inspect}"
+					@packer.write(message)
+					@packer.flush
+				end
+				
+				def close
+					@transactions.each do |id, transaction|
+						transaction.close
+					end
+					
+					@peer.close
 				end
 				
+				def inspect
+					"#<#{self.class} #{@objects.size} objects>"
+				end
+				
+				attr :objects
+				attr :proxies
+				
 				attr :unpacker
 				attr :packer
 				
@@ -68,72 +84,152 @@ module Async
 				
 				attr :transactions
 				
+				Explicit = Struct.new(:object) do
+					def temporary?
+						false
+					end
+				end
+				
+				Implicit = Struct.new(:object) do
+					def temporary?
+						true
+					end
+				end
+				
+				# Bind a local object to a name, such that it could be accessed remotely.
+				#
+				# @returns [Proxy] A proxy instance for the bound object.
+				def bind(name, object)
+					# Bind the object into the local object store (explicitly bound, not temporary):
+					@objects[name] = Explicit.new(object)
+					
+					# Return the proxy instance for the bound object:
+					return self[name]
+				end
+				
+				# Generate a proxy name for an object and bind it.
+				#
+				# @returns [Proxy] A proxy instance for the bound object.
 				def proxy(object)
-					name = "proxy:#{object_id}"
+					name = "<#{object.class}@#{next_id.to_s(16)}>".freeze
+					
+					# Bind the object into the local object store (temporary):
+					@objects[name] = Implicit.new(object)
+					
+					# This constructs the Proxy instance:
+					return self[name]
+				end
+				
+				# Generate a proxy name for an object and bind it, returning just the name.
+				# Used for serialization when you need the name string, not a Proxy instance.
+				#
+				# @returns [String] The name of the bound object.
+				def proxy_name(object)
+					name = "<#{object.class}@#{next_id.to_s(16)}>".freeze
 					
-					bind(name, object)
+					# Bind the object into the local object store (temporary):
+					@objects[name] = Implicit.new(object)
 					
+					# Return the name:
 					return name
 				end
 				
-				def bind(name, object)
-					@objects[name] = object
+				def object(name)
+					@objects[name]&.object
 				end
 				
-				def [](name)
-					Proxy.new(self, name)
+				private def finalize(name)
+					proc do
+						@finalized.push(name) rescue nil
+					end
 				end
 				
-				def invoke(name, arguments, options, &block)
-					id = self.next_id
+				def []=(name, object)
+					@objects[name] = Explicit.new(object)
+				end
+				
+				def [](name)
+					unless proxy = @proxies[name]
+						proxy = Proxy.new(self, name)
+						@proxies[name] = proxy
+						
+						::ObjectSpace.define_finalizer(proxy, finalize(name))
+					end
 					
-					transaction = Transaction.new(self, id)
+					return proxy
+				end
+				
+				def transaction!(id = self.next_id)
+					transaction = Transaction.new(self, id, timeout: @timeout)
 					@transactions[id] = transaction
 					
+					return transaction
+				end
+				
+				def invoke(name, arguments, options = {}, &block)
+					transaction = self.transaction!
+					
 					transaction.invoke(name, arguments, options, &block)
+				ensure
+					transaction&.close
+				end
+				
+				def send_release(name)
+					self.write(Release.new(name))
 				end
 				
-				def run
-					# @unpacker.each do |message|
+				def run(parent: Task.current)
+					finalizer_task = parent.async do
+						while name = @finalized.pop
+							self.send_release(name)
+						end
+					end
+					
 					@unpacker.each do |message|
-						id = message.shift
-						
-						if transaction = @transactions[id]
-							transaction.received.enqueue(message)
-						elsif message.first == :invoke
-							message.shift
-							
-							transaction = Transaction.new(self, id)
-							@transactions[id] = transaction
-							
-							name = message.shift
-							object = @objects[name]
-							
-							Async do
-								transaction.accept(object, *message)
-							ensure
-								transaction.close
+						case message
+						when Invoke
+							# If the object is not found, send an error response and skip the transaction:
+							if object = @objects[message.name]&.object
+								transaction = self.transaction!(message.id)
+								
+								parent.async(annotation: "Invoke #{message.name}") do
+									# $stderr.puts "-> Accepting: #{message.name} #{message.arguments.inspect} #{message.options.inspect}"
+									transaction.accept(object, message.arguments, message.options, message.block_given)
+								ensure
+									# $stderr.puts "<- Accepted: #{message.name}"
+									# This will also delete the transaction from @transactions:
+									transaction.close
+								end
+							else
+								self.write(Error.new(message.id, NameError.new("Object not found: #{message.name}")))
+							end
+						when Response
+							if transaction = @transactions[message.id]
+								transaction.push(message)
+							else
+								# Stale message - transaction already closed (e.g. timeout) or never existed (ignore silently).
+							end
+						when Release
+							name = message.name
+							if @objects[name]&.temporary?
+								# Only delete temporary objects, not explicitly bound ones:
+								@objects.delete(name)
 							end
 						else
-							raise "Out of order message: #{message}"
+							Console.error(self, "Unexpected message:", message)
 						end
 					end
 				ensure
-					@transactions.each do |id, transaction|
-						transaction.close
-					end
+					finalizer_task&.stop
 					
-					@transactions.clear
-				end
-				
-				def close
 					@transactions.each do |id, transaction|
 						transaction.close
 					end
 					
-					@peer.close
+					@transactions.clear
+					@proxies = ::ObjectSpace::WeakMap.new
 				end
 			end
 		end
 	end
-end
+end

data/lib/async/bus/protocol/invoke.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "msgpack"
+require_relative "proxy"
+
+module Async
+	module Bus
+		module Protocol
+			# Represents a method invocation.
+			class Invoke
+				def initialize(id, name, arguments, options, block_given)
+					@id = id
+					@name = name
+					@arguments = arguments
+					@options = options
+					@block_given = block_given
+				end
+				
+				attr :id
+				attr :name
+				attr :arguments
+				attr :options
+				attr :block_given
+				
+				def pack(packer)
+					packer.write(@id)
+					packer.write(@name)
+					
+					packer.write(@arguments.size)
+					@arguments.each do |argument|
+						packer.write(argument)
+					end
+					
+					packer.write(@options.size)
+					@options.each do |key, value|
+						packer.write(key)
+						packer.write(value)
+					end
+					
+					packer.write(@block_given)
+				end
+				
+				def self.unpack(unpacker)
+					id = unpacker.read
+					name = unpacker.read
+					arguments = Array.new(unpacker.read){unpacker.read}
+					options = Array.new(unpacker.read){[unpacker.read, unpacker.read]}.to_h
+					block_given = unpacker.read
+					
+					return self.new(id, name, arguments, options, block_given)
+				end
+			end
+		end
+	end
+end

data/lib/async/bus/protocol/proxy.rb

@@ -1,42 +1,54 @@
-# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
-# 
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-# 
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-# 
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2021-2025, by Samuel Williams.
 
 module Async
 	module Bus
 		module Protocol
+			# A proxy object that forwards method calls to a remote object.
+			#
+			# We must be extremely careful not to invoke any methods on the proxy object that would recursively call the proxy object.
 			class Proxy < BasicObject
-				def initialize(bus, name)
-					@bus = bus
+				# Create a new proxy object.
+				#
+				# @parameter connection [Connection] The connection to the remote object.
+				# @parameter name [Symbol] The name (address) of the remote object.
+				def initialize(connection, name)
+					@connection = connection
 					@name = name
 				end
 				
-				def inspect
-					"[Proxy #{method_missing(:inspect)}]"
+				def __name__
+					@name
+				end
+				
+				def !
+					@connection.invoke(@name, [:!])
+				end
+				
+				def == object
+					@connection.invoke(@name, [:==, object])
+				end
+				
+				def != object
+					@connection.invoke(@name, [:!=, object])
 				end
 				
 				def method_missing(*arguments, **options, &block)
-					@bus.invoke(@name, arguments, options, &block)
+					@connection.invoke(@name, arguments, options, &block)
 				end
 				
 				def respond_to?(name, include_all = false)
-					@bus.invoke(@name, [:respond_to?, name, include_all])
+					@connection.invoke(@name, [:respond_to?, name, include_all])
+				end
+				
+				def respond_to_missing?(name, include_all = false)
+					@connection.invoke(@name, [:respond_to?, name, include_all])
+				end
+				
+				def inspect
+					"#<proxy #{@name}: #{@connection.invoke(@name, [:inspect])}>"
 				end
 			end
 		end

data/lib/async/bus/protocol/release.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module Bus
+		module Protocol
+			# Represents a named object that has been released (no longer available).
+			class Release
+				def initialize(name)
+					@name = name
+				end
+				
+				attr :name
+				
+				def pack(packer)
+					packer.write(@name)
+				end
+				
+				def self.unpack(unpacker)
+					name = unpacker.read
+					
+					return self.new(name)
+				end
+			end
+		end
+	end
+end