sumac 0.0.0

data/lib/sumac/adapter.rb

@@ -0,0 +1,5 @@
+class Sumac
+  module Adapter
+  
+  end
+end

data/lib/sumac/adapter/closed.rb

@@ -0,0 +1,7 @@
+class Sumac
+  module Adapter
+    class ClosedError < StandardError
+    
+    end
+  end
+end

data/lib/sumac/argument_error.rb

@@ -0,0 +1,5 @@
+class Sumac
+  class ArgumentError < StandardError
+  
+  end
+end

data/lib/sumac/call_dispatcher.rb

@@ -0,0 +1,70 @@
+class Sumac
+  class CallDispatcher
+    
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+      @pending_requests = {}
+      @id_allocator = IDAllocator.new
+    end
+    
+    def any_calls_pending?
+      @pending_requests.any?
+    end
+    
+    def kill_all
+      raise unless @connection.at?(:kill)
+      @pending_requests.each do |id, waiter|
+        @pending_requests.delete(id)
+        waiter.resume(nil)
+      end
+    end
+    
+    def make_call(remote_object, method_name, arguments)
+      raise unless remote_object.is_a?(RemoteObject) || remote_object.is_a?(RemoteObjectChild)
+      raise ClosedError unless @connection.at?(:active)
+      id = @id_allocator.allocate
+      request = Message::Exchange::CallRequest.new(@connection)
+      request.id = id
+      @connection.local_references.start_transaction
+      @connection.remote_references.start_transaction
+      begin
+        request.exposed_object = remote_object
+        request.method_name = method_name
+        request.arguments = arguments
+      rescue StandardError => e # MessageError, StaleObjectError
+        @connection.local_references.rollback_transaction
+        @connection.remote_references.rollback_transaction
+        raise e
+      else
+        @connection.local_references.commit_transaction
+        @connection.remote_references.commit_transaction
+      end
+      @connection.messenger.send(request)
+      raise ClosedError if @connection.at?([:kill, :close])
+      waiter = QuackConcurrency::Waiter.new
+      @pending_requests[id] = waiter
+      @connection.mutex.unlock
+      response = waiter.wait
+      @connection.mutex.lock
+      @id_allocator.free(id)
+      @connection.closer.job_finished
+      raise ClosedError if response == nil
+      raise response.exception if response.exception
+      response.return_value
+    ensure
+      @id_allocator.free(id) if id && @id_allocator.allocated?(id)
+    end
+    
+    def receive(exchange)
+      raise MessageError unless @connection.at?([:active, :initiate_shutdown, :shutdown])
+      raise MessageError unless exchange.is_a?(Message::Exchange::CallResponse)
+      waiter = @pending_requests[exchange.id]
+      @pending_requests.delete(exchange.id)
+      raise MessageError unless waiter
+      waiter.resume(exchange)
+      nil
+    end
+    
+  end
+end

data/lib/sumac/call_processor.rb

@@ -0,0 +1,93 @@
+class Sumac
+  class CallProcessor
+    include Emittable
+    
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+      @pending_calls = 0
+    end
+    
+    def any_calls_processing?
+      @pending_calls > 0
+    end
+    
+    def receive(exchange)
+      raise MessageError unless exchange.is_a?(Message::Exchange::CallRequest)
+      raise MessageError unless @connection.at?([:active, :initiate_shutdown])
+      raise MessageError unless exchange.exposed_object.is_a?(ExposedObject) || exchange.exposed_object.is_a?(ExposedObjectChild)
+      response = process(exchange)
+      @connection.messenger.send(response) if response
+      finished
+      nil
+    end
+    
+    private
+    
+    def process(request)
+      @pending_calls += 1
+      response = Message::Exchange::CallResponse.new(@connection)
+      response.id = request.id
+      # validate_exposed_object_exist
+      begin
+        exposed_object = request.exposed_object
+      rescue MessageError
+        response.exception = MessageError.new
+        return response
+      end
+      # validate_method_exposed
+      unless request.exposed_object.__exposed_methods__.include?(request.method_name)
+        response.exception = NoMethodError.new
+        return response
+      end
+      # validate_arguments
+      @connection.local_references.start_transaction
+      @connection.remote_references.start_transaction
+      begin
+        arguments = request.arguments
+      rescue StandardError => e
+        response.exception = e
+        @connection.local_references.rollback_transaction
+        @connection.remote_references.rollback_transaction
+        return response
+      else
+        @connection.local_references.commit_transaction
+        @connection.remote_references.commit_transaction
+      end
+      # call method
+      @connection.mutex.unlock
+      begin
+        return_value = exposed_object.__send__(request.method_name, *arguments)
+      rescue StandardError => e
+        exception_raised = e
+      end
+      @connection.mutex.lock
+      return if @connection.at?(:kill)
+      if exception_raised
+        response.exception = exception_raised
+        return response
+      else
+        @connection.local_references.start_transaction
+        @connection.remote_references.start_transaction
+        begin
+          response.return_value = return_value
+        rescue StandardError => e # MessageError, StaleObjectError, UnexposableError
+          response.exception = e
+          @connection.local_references.rollback_transaction
+          @connection.remote_references.rollback_transaction
+          return response
+        else
+          @connection.local_references.commit_transaction
+          @connection.remote_references.commit_transaction
+        end
+      end
+      return response
+    end
+    
+    def finished
+      @pending_calls -= 1
+      @connection.closer.job_finished
+    end
+    
+  end
+end

data/lib/sumac/closed_error.rb

@@ -0,0 +1,5 @@
+class Sumac
+  class ClosedError < StandardError
+  
+  end
+end

data/lib/sumac/closer.rb

@@ -0,0 +1,53 @@
+class Sumac
+  class Closer
+  
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+      @future = QuackConcurrency::Future.new
+    end
+    
+    def job_finished
+      try_close if @connection.at?([:shutdown, :kill])
+      nil
+    end
+    
+    def try_close
+      @connection.to(:close) if can_close?
+      nil
+    end
+    
+    def close
+      @connection.mutex.synchronize do
+        case @connection.at.to_sym
+        when :initial, :compatibility_handshake, :initialization_handshake
+          @connection.to(:kill)
+        when :active
+          @connection.to(:initiate_shutdown)
+        end
+      end
+      @future.get
+      @connection.scheduler.join
+      nil
+    end
+    
+    def complete
+      @future.set
+      nil
+    end
+    
+    def join
+      @future.get
+      @connection.scheduler.join
+      nil
+    end
+    
+    private
+    
+    def can_close?
+      !@connection.call_dispatcher.any_calls_pending? &&
+        !@connection.call_processor.any_calls_processing?
+    end
+    
+  end
+end

data/lib/sumac/connection.rb

@@ -0,0 +1,94 @@
+class Sumac
+  class Connection
+    include QueuedStateMachine
+    
+    state :initial, initial: true
+    state :compatibility_handshake
+    state :initialization_handshake
+    state :active
+    state :initiate_shutdown
+    state :shutdown
+    state :kill
+    state :close
+    
+    transition from: :initial,                  to: :compatibility_handshake
+    transition from: :compatibility_handshake,  to: [:initialization_handshake, :kill]
+    transition from: :initialization_handshake, to: [:active, :kill]
+    transition from: :active,                   to: [:initiate_shutdown, :shutdown, :kill]
+    transition from: :initiate_shutdown,        to: [:shutdown, :kill]
+    transition from: :shutdown,                 to: [:close, :kill]
+    transition from: :kill,                     to: :close
+    
+    on_transition(from: :initial, to: :compatibility_handshake) do
+      @handshake.send_compatibility_notification
+    end
+    
+    on_transition(from: :compatibility_handshake, to: :initialization_handshake) do
+      @handshake.send_initialization_notification
+    end
+    
+    on_transition(from: [:compatibility_handshake, :initialization_handshake], to: :kill) do
+      @local_references.detach
+      @remote_references.detach
+    end
+    
+    on_transition(from: :active) do
+      @local_references.detach
+      @remote_references.detach
+    end
+    
+    on_transition(from: :active, to: [:initiate_shutdown, :shutdown]) do
+      @shutdown.send_notification
+    end
+    
+    on_transition(from: :active, to: [:initiate_shutdown, :shutdown, :kill]) do
+      @sumac.trigger(:shutdown)
+    end
+    
+    on_transition(to: [:shutdown, :kill]) do
+      @closer.try_close
+    end
+    
+    on_transition(to: :kill) do
+      @call_dispatcher.kill_all
+    end
+    
+    on_transition(to: [:kill, :close]) do
+      @remote_entry.cancel
+    end
+    
+    on_transition(to: :close) do
+      @messenger.close
+      @local_references.destroy
+      @remote_references.destroy
+      @closer.complete
+      @sumac.trigger(:close)
+    end
+    
+    attr_reader :mutex, :sumac, :call_dispatcher, :call_processor,
+      :handshake, :shutdown, :local_references, :remote_references,
+      :local_entry, :messenger, :remote_entry, :scheduler,
+      :closer, :messenger_adapter
+    
+    attr_accessor :remote_entry
+    
+    def initialize(sumac, duck_types: , entry: , messenger: , workers: )
+      super()
+      @sumac = sumac
+      @local_entry = entry
+      @messenger_adapter = messenger
+      @remote_entry = RemoteEntry.new
+      @mutex = Mutex.new
+      @messenger = Messenger.new(self)
+      @call_dispatcher = CallDispatcher.new(self)
+      @call_processor = CallProcessor.new(self)
+      @handshake = Handshake.new(self)
+      @shutdown = Shutdown.new(self)
+      @local_references = LocalReferences.new(self)
+      @remote_references = RemoteReferences.new(self)
+      @scheduler = Scheduler.new(self, workers)
+      @closer = Closer.new(self)
+    end
+    
+  end
+end

data/lib/sumac/exposed_object.rb

@@ -0,0 +1,131 @@
+class Sumac
+  module ExposedObject
+    
+    def self.included(base)
+      base.extend(IncludedClassMethods)
+      base.include(IncludedInstanceMethods)
+    end
+    
+    def self.extended(base)
+      base.extend(ExtendedClassMethods)
+    end
+    
+    
+    module IncludedClassMethods
+      
+      def inherited(base)
+        base.instance_variable_set(:@__exposed_methods__, @__exposed_methods__.dup)
+        base.instance_variable_set(:@__child_accessor__, @__child_accessor__)
+      end
+      
+      attr_reader :__child_accessor__
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+      end
+      
+      def child_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'child_accessor' expects a method name as a string for symbol"
+        end
+        @__child_accessor__ = method_name.to_s
+      end
+      
+      def expose(*method_names)
+        raise ArgumentError, 'at least one argument expected' if method_names.empty?
+        unless method_names.each { |method_name| method_name.is_a?(Symbol) || method_name.is_a?(String) }
+          raise 'only symbols or strings expected'  
+        end
+        @__exposed_methods__ ||= []
+        @__exposed_methods__.concat(method_names.map(&:to_s))
+      end
+      
+    end
+    
+    
+    module IncludedInstanceMethods
+      
+      def __child__(key)
+        raise 'child_accessor not defined' unless __child_accessor__
+        __send__(__child_accessor__, key)
+      end
+      
+      def __child_accessor__
+        @__child_accessor__ || self.class.__child_accessor__
+      end
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+        @__exposed_methods__ + self.class.__exposed_methods__
+      end
+      
+      def __native_id__
+        __id__
+      end
+      
+      def __sumac_exposed_object__
+      end
+      
+      def child_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'child_accessor' expects a method name as a string for symbol"
+        end
+        @__child_accessor__ = method_name.to_s
+      end
+      
+      def expose(*method_names)
+        raise ArgumentError, 'at least one argument expected' if method_names.empty?
+        unless method_names.each { |method_name| method_name.is_a?(Symbol) || method_name.is_a?(String) }
+          raise 'only symbols or strings expected'  
+        end
+        @__exposed_methods__ ||= []
+        @__exposed_methods__.concat(method_names.map(&:to_s))
+      end
+      
+    end
+    
+    
+    module ExtendedClassMethods
+      
+      def inherited(base)
+        base.instance_variable_set(:@__exposed_methods__, @__exposed_methods__.dup)
+        base.instance_variable_set(:@__child_accessor__, @__child_accessor__)
+      end
+      
+      def __child__(key)
+        raise 'child_accessor not defined' unless @__child_accessor__
+        __send__(@__child_accessor__, key)
+      end
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+      end
+      
+      def __native_id__
+        __id__
+      end
+      
+      def __sumac_exposed_object__
+      end
+      
+      def child_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'child_accessor' expects a method name as a string for symbol"
+        end
+        @__child_accessor__ = method_name.to_s
+      end
+      
+      def expose(*method_names)
+        raise ArgumentError, 'at least one argument expected' if method_names.empty?
+        unless method_names.each { |method_name| method_name.is_a?(Symbol) || method_name.is_a?(String) }
+          raise 'only symbols or strings expected'  
+        end
+        @__exposed_methods__ ||= []
+        @__exposed_methods__.concat(method_names.map(&:to_s))
+      end
+      
+    end
+    
+    
+  end
+end