sumac 0.0.0

data/lib/sumac/message/object/hash_table.rb

@@ -0,0 +1,75 @@
+class Sumac
+  class Message
+    class Object
+      class HashTable < Base
+      
+        def initialize(connection)
+          super
+          @entries = nil
+        end
+        
+        def parse_json_structure(json_structure)
+          raise MessageError unless json_structure.is_a?(::Hash) &&
+            json_structure['message_type'] == 'object' &&
+            json_structure['object_type'] == 'hash_table'
+          raise MessageError unless json_structure['entries'].is_a?(::Array)
+          @entries = json_structure['entries'].map do |entry|
+            raise MessageError unless entry.is_a?(::Hash) && entry.include?('key') && entry.include?('value')
+            {
+              'key' => Object.from_json_structure(@connection, entry['key']),
+              'value' => Object.from_json_structure(@connection, entry['value'])
+            }
+          end
+          nil
+        end
+        
+        def parse_native_object(native_object)
+          raise MessageError unless native_object.is_a?(::Hash)
+          @entries = native_object.map do |key, value|
+            {
+              'key' => Object.from_native_object(@connection, key),
+              'value' => Object.from_native_object(@connection, value)
+            }
+          end
+          nil
+        end
+        
+        def to_json_structure
+          raise MessageError unless setup?
+          json_entries = @entries.map do |entry|
+            {
+              'key' => entry['key'].to_json_structure,
+              'value' => entry['value'].to_json_structure
+            }
+          end
+          {
+            'message_type' => 'object',
+            'object_type' => 'hash_table',
+            'entries' => json_entries
+          }
+        end
+        
+        def to_native_object
+          raise MessageError unless setup?
+          @entries.map { |entry| [entry['key'].to_native_object, entry['value'].to_native_object] }.to_h
+        end
+        
+        def invert_orgin
+          raise MessageError unless setup?
+          @entries.each do |entry|
+            entry['key'].invert_orgin if entry['key'].respond_to?(:invert_orgin)
+            entry['value'].invert_orgin if entry['value'].respond_to?(:invert_orgin)
+          end
+          nil
+        end
+        
+        private
+        
+        def setup?
+          @entries != nil
+        end
+        
+      end
+    end
+  end
+end

data/lib/sumac/message/object/integer.rb

@@ -0,0 +1,45 @@
+class Sumac
+  class Message
+    class Object
+      class Integer < Base
+      
+        def initialize(connection)
+          super
+          @value = nil
+        end
+        
+        def parse_json_structure(json_structure)
+          raise MessageError unless json_structure.is_a?(::Hash) &&
+            json_structure['message_type'] == 'object' &&
+            json_structure['object_type'] == 'integer'
+          raise MessageError unless json_structure['value'].is_a?(::Numeric)
+          @value = json_structure['value'].to_i
+          nil
+        end
+        
+        def parse_native_object(native_object)
+          raise MessageError unless native_object.is_a?(::Integer)
+          @value = native_object
+          nil
+        end
+        
+        def to_json_structure
+          raise MessageError unless setup?
+          {'message_type' => 'object', 'object_type' => 'integer', 'value' => @value}
+        end
+        
+        def to_native_object
+          raise MessageError unless setup?
+          @value
+        end
+        
+        private
+        
+        def setup?
+          @value != nil
+        end
+        
+      end
+    end
+  end
+end

data/lib/sumac/message/object/native_exception.rb

@@ -0,0 +1,56 @@
+class Sumac
+  class Message
+    class Object
+      class NativeException < Base
+      
+        def initialize(connection)
+          super
+          @type = nil
+          @message = nil
+        end
+        
+        def parse_json_structure(json_structure)
+          raise MessageError unless json_structure.is_a?(::Hash) &&
+            json_structure['message_type'] == 'object' &&
+            json_structure['object_type'] == 'native_exception'
+          raise MessageError unless json_structure['type'].is_a?(::String)
+          @type = json_structure['type']
+          if json_structure['message']
+            raise MessageError unless json_structure['message'].is_a?(::String)
+            @message = json_structure['message']
+          end
+          nil
+        end
+        
+        def parse_native_object(native_object)
+          raise MessageError unless native_object.kind_of?(::Exception)
+          @type = native_object.class.to_s
+          @message = native_object.message
+          nil
+        end
+        
+        def to_json_structure
+          raise MessageError unless setup?
+          {
+            'message_type' => 'object',
+            'object_type' => 'native_exception',
+            'type' => @type,
+            'message' => @message
+          }
+        end
+        
+        def to_native_object
+          raise MessageError unless setup?
+          NativeError.new(@type, @message)
+        end
+        
+        private
+        
+        def setup?
+          @type != nil
+        end
+        
+      end
+    end
+  end
+end

data/lib/sumac/message/object/null.rb

@@ -0,0 +1,44 @@
+class Sumac
+  class Message
+    class Object
+      class Null < Base
+      
+        def initialize(connection)
+          super
+          @setup = false
+        end
+        
+        def parse_json_structure(json_structure)
+          raise MessageError unless json_structure.is_a?(::Hash) &&
+            json_structure['message_type'] == 'object' &&
+            json_structure['object_type'] == 'null'
+          @setup = true
+          nil
+        end
+        
+        def parse_native_object(native_object)
+          raise MessageError unless native_object == nil
+          @setup = true
+          nil
+        end
+        
+        def to_json_structure
+          raise MessageError unless setup?
+          {'message_type' => 'object', 'object_type' => 'null'}
+        end
+        
+        def to_native_object
+          raise MessageError unless setup?
+          nil
+        end
+        
+        private
+        
+        def setup?
+          @setup
+        end
+        
+      end
+    end
+  end
+end

data/lib/sumac/message/object/string.rb

@@ -0,0 +1,45 @@
+class Sumac
+  class Message
+    class Object
+      class String < Base
+      
+        def initialize(connection)
+          super
+          @value = nil
+        end
+        
+        def parse_json_structure(json_structure)
+          raise MessageError unless json_structure.is_a?(::Hash) &&
+            json_structure['message_type'] == 'object' &&
+            json_structure['object_type'] == 'string'
+          raise MessageError unless json_structure['value'].is_a?(::String)
+          @value = json_structure['value']
+          nil
+        end
+        
+        def parse_native_object(native_object)
+          raise MessageError unless native_object.is_a?(::String)
+          @value = native_object
+          nil
+        end
+        
+        def to_json_structure
+          raise MessageError unless setup?
+          {'message_type' => 'object', 'object_type' => 'string', 'value' => @value}
+        end
+        
+        def to_native_object
+          raise MessageError unless setup?
+          @value
+        end
+        
+        private
+        
+        def setup?
+          @value != nil
+        end
+        
+      end
+    end
+  end
+end

data/lib/sumac/message_error.rb

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

data/lib/sumac/messenger.rb

@@ -0,0 +1,65 @@
+class Sumac
+  class Messenger
+  
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+    end
+    
+    def send(message)
+      raise unless message.is_a?(Message::Exchange)
+      raise if @connection.at?([:kill, :close])
+      message.invert_orgin
+      message_string = message.to_json
+      begin
+        @connection.messenger_adapter.send(message_string)
+      rescue Adapter::ClosedError
+        unless @connection.at?(:close)
+          @connection.to(:kill)
+        end
+      end
+      nil
+    end
+    
+    def receive(message_string)
+      begin
+        process(message_string)
+      rescue MessageError
+        @connection.sumac.trigger(:protocol_error)
+        unless @connection.at?(:close)
+          @connection.to(:kill)
+        end
+      end
+    end
+    
+    def close
+      begin
+        @connection.messenger_adapter.close
+      rescue Adapter::ClosedError
+      end
+    end
+    
+    private
+    
+    def process(message_string)
+      exchange = Message::Exchange.from_json(@connection, message_string)
+      case exchange
+      when Message::Exchange::CompatibilityNotification, Message::Exchange::InitializationNotification
+        @connection.handshake.receive(exchange)
+      when Message::Exchange::CallRequest
+        @connection.call_processor.receive(exchange)
+      when Message::Exchange::CallResponse
+        @connection.call_dispatcher.receive(exchange)
+      when Message::Exchange::ShutdownNotification
+        @connection.shutdown.receive(exchange)
+      when Message::Exchange::ForgetNotification
+        reference = exchange.reference
+        reference.remote_forget_request
+      else
+        raise MessageError
+      end
+      nil
+    end
+    
+  end
+end

data/lib/sumac/native_error.rb

@@ -0,0 +1,17 @@
+class Sumac
+  class NativeError < StandardError
+  
+    attr_reader :native_type, :native_message
+    
+    def initialize(native_type, native_message)
+      super()
+      @native_type = native_type
+      @native_message = native_message
+    end
+    
+    def message
+      "#{@native_type} -> #{@native_message}"
+    end
+    
+  end
+end

data/lib/sumac/no_method_error.rb

@@ -0,0 +1,9 @@
+class Sumac
+  class NoMethodError < StandardError
+  
+    def message
+      "method is undefined or has not been exposed"
+    end
+    
+  end
+end

data/lib/sumac/reference.rb

@@ -0,0 +1,68 @@
+class Sumac
+  class Reference
+    include QueuedStateMachine
+    
+    state :active, initial: true
+    state :forget_requested
+    state :detached
+    state :stale
+    
+    transition from: :active, to: [:forget_requested, :detached, :stale]
+    transition from: :forget_requested, to: [:detached, :stale]
+    transition from: :detached, to: :stale
+    
+    on_transition(from: :active, to: [:forget_requested, :stale]) do
+      send_forget_notification
+    end
+    
+    on_transition(to: :stale) do
+      remove
+      @forget_condition_variable.broadcast
+    end
+    
+    attr_reader :exposed_id
+    
+    def initialize(connection, exposed_id)
+      super()
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+      raise unless exposed_id.is_a?(Integer)
+      @exposed_id = exposed_id
+      @forget_condition_variable = ConditionVariable.new
+    end
+    
+    def local_forget_request
+      to(:forget_requested) if at?(:active)
+      @forget_condition_variable.wait(@connection.mutex) if at?([:forget_requested, :detached])
+    end
+    
+    def remote_forget_request
+      raise if at?([:detached, :stale])
+      to(:stale)
+    end
+    
+    def send_forget_notification
+      message = Message::Exchange::ForgetNotification.new(@connection)
+      message.reference = self
+      @connection.messenger.send(message)
+    end
+    
+    def detach
+      to(:detached)
+    end
+    
+    def callable?
+      at?(:active)
+    end
+    
+    def destroy
+      raise unless at?(:detached)
+      to(:stale)
+    end
+    
+    def stale?
+      at?(:stale)
+    end
+    
+  end
+end

data/lib/sumac/remote_entry.rb

@@ -0,0 +1,42 @@
+class Sumac
+  class RemoteEntry
+  
+    def initialize
+      @mutex = Mutex.new
+      @condition_variable = ConditionVariable.new
+      @value = nil
+      @value_set = false
+      @complete = false
+    end
+    
+    def cancel
+      @mutex.synchronize do
+        @complete = true
+        @value_set = false
+        @value = false
+      end
+    end
+    
+    def get
+      @mutex.synchronize do
+        @condition_variable.wait(@mutex) unless complete?
+        raise ClosedError unless @value_set
+        @value
+      end
+    end
+    
+    def set(new_value = nil)
+      @mutex.synchronize do
+        @value_set = true
+        @complete = true
+        @value = new_value
+        @condition_variable.broadcast
+      end
+    end
+    
+    def complete?
+      @complete
+    end
+    
+  end
+end