sumac 0.0.0

data/lib/sumac/exposed_object_child.rb

@@ -0,0 +1,158 @@
+class Sumac
+  module ExposedObjectChild
+    
+    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(:@__parent_accessor__, @__parent_accessor__)
+        base.instance_variable_set(:@__key_accessor__, @__key_accessor__)
+      end
+      
+      attr_reader :__parent_accessor__, :__key_accessor__
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+      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
+      
+      def parent_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__parent_accessor__ = method_name.to_s
+      end
+      
+      def key_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__key_accessor__ = method_name.to_s
+      end
+      
+    end
+    
+    module IncludedInstanceMethods
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+        @__exposed_methods__ + self.class.__exposed_methods__
+      end
+      
+      def __parent__
+        raise 'parent_accessor not defined' unless __parent_accessor__
+        __send__(__parent_accessor__)
+      end
+      
+      def __parent_accessor__
+        @__parent_accessor__ || self.class.__parent_accessor__
+      end
+      
+      def __key__
+        raise 'key_accessor not defined' unless __key_accessor__
+        __send__(__key_accessor__)
+      end
+      
+      def __key_accessor__
+        @__key_accessor__ || self.class.__key_accessor__
+      end
+      
+      def __sumac_exposed_object__
+      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
+      
+      def parent_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__parent_accessor__ = method_name.to_s
+      end
+      
+      def key_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__key_accessor__ = method_name.to_s
+      end
+      
+    end
+    
+    
+    module ExtendedClassMethods
+      
+      def inherited(base)
+        base.instance_variable_set(:@__exposed_methods__, @__exposed_methods__.dup)
+        base.instance_variable_set(:@__parent_accessor__, @__parent_accessor__)
+        base.instance_variable_set(:@__key_accessor__, @__key_accessor__)
+      end
+      
+      def __exposed_methods__
+        @__exposed_methods__ ||= []
+      end
+      
+      def __parent__
+        raise 'parent_accessor not defined' unless @__parent_accessor__
+        __send__(@__parent_accessor__)
+      end
+      
+      def __key__
+        raise 'key_accessor not defined' unless @__key_accessor__
+        __send__(@__key_accessor__)
+      end
+      
+      def __sumac_exposed_object__
+      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
+      
+      def parent_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__parent_accessor__ = method_name.to_s
+      end
+      
+      def key_accessor(method_name = nil)
+        unless method_name.is_a?(Symbol) || method_name.is_a?(String)
+          raise ArgumentError, "'parent_accessor' expects a method name as a string for symbol"
+        end
+        @__key_accessor__ = method_name.to_s
+      end
+      
+    end
+    
+  end
+end

data/lib/sumac/forgoten.rb

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

data/lib/sumac/handshake.rb

@@ -0,0 +1,48 @@
+class Sumac
+  class Handshake
+    include Emittable
+    
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+    end
+    
+    def send_compatibility_notification
+      message = Message::Exchange::CompatibilityNotification.new(@connection)
+      message.protocol_version = 1
+      @connection.messenger.send(message)
+      nil
+    end
+    
+    def send_initialization_notification
+      message = Message::Exchange::InitializationNotification.new(@connection)
+      begin
+        message.entry = @connection.local_entry
+      rescue UnexposableObjectError
+        @connection.to(:kill)
+      else
+        @connection.messenger.send(message)
+      end
+      nil
+    end
+    
+    def receive(message)
+      case message
+      when Message::Exchange::CompatibilityNotification
+        raise MessageError unless @connection.at?(:compatibility_handshake)
+        #unless message.protocol_version == 1
+        #  @connection.to(:kill)
+        #end
+        @connection.to(:initialization_handshake)
+      when Message::Exchange::InitializationNotification
+        raise MessageError unless @connection.at?(:initialization_handshake)
+        @connection.to(:active)
+        @connection.remote_entry.set(message.entry)
+      else
+        raise MessageError
+      end
+      nil
+    end
+    
+  end
+end

data/lib/sumac/id_allocator.rb

@@ -0,0 +1,99 @@
+class Sumac
+  class IDAllocator
+    
+    def self.valid?(id)
+      id.is_a?(Integer) && id >= 0
+    end
+    
+    def initialize
+      @allocated_ranges = []
+      @mutex = Mutex.new
+    end
+    
+    def valid?(id)
+      self.class.valid?(id)
+    end
+    
+    def allocate
+      @mutex.lock
+      if @allocated_ranges.empty?
+        id = 0
+      elsif @allocated_ranges.first.first == 0
+        id = @allocated_ranges.first.last.succ
+      else
+        id = 0
+      end
+      
+      preceding_range = @allocated_ranges.take_while{ |range| range.last < id }.last
+      preceding_range_index = @allocated_ranges.find_index(preceding_range) if preceding_range
+      
+      following_range_index = @allocated_ranges.find_index { |range| range.first > id }
+      following_range = @allocated_ranges[following_range_index] if following_range_index
+      
+      immediately_preceding_range = preceding_range if preceding_range && preceding_range.last.succ == id
+      immediately_following_range = following_range if following_range && following_range.first.pred == id
+      
+      if immediately_preceding_range && immediately_following_range
+        @allocated_ranges[preceding_range_index] = (preceding_range.first..following_range.last)
+        @allocated_ranges.delete(following_range)
+      elsif immediately_preceding_range
+        @allocated_ranges[preceding_range_index] = (preceding_range.first..id)
+      elsif immediately_following_range
+        @allocated_ranges[following_range_index] = (id..following_range.last)
+      else
+        new_index = preceding_range ? preceding_range_index.succ : 0
+        @allocated_ranges.insert(new_index, (id..id))
+      end
+      
+      @mutex.unlock
+      
+      if block_given?
+        begin
+          yield(id)
+        ensure
+          free(id)
+        end
+      else
+        id
+      end
+    end
+    
+    def free(id)
+      @mutex.lock
+      raise unless valid?(id) && allocated?(id)
+      
+      enclosing_range = enclosing_range(id)
+      enclosing_range_index = @allocated_ranges.find_index(enclosing_range)
+      
+      if enclosing_range.size == 1
+        @allocated_ranges.delete(enclosing_range)
+      elsif enclosing_range.first == id
+        @allocated_ranges[enclosing_range_index] = (enclosing_range.first.succ..enclosing_range.last)
+      elsif enclosing_range.last == id
+        @allocated_ranges[enclosing_range_index] = (enclosing_range.first..enclosing_range.last.pred)
+      else
+        @allocated_ranges[enclosing_range_index] = (enclosing_range.first..id.pred)
+        @allocated_ranges.insert(enclosing_range_index.succ, (id.succ..enclosing_range.last))
+      end
+      
+      @mutex.unlock
+      nil
+    end
+    
+    def allocated?(id)
+      enclosing_range(id)
+    end
+    
+    private
+    
+    def free?(id)
+      !allocated?(id)
+    end
+    
+    def enclosing_range(id)
+      possible_range = @allocated_ranges.find{ |range| range.last >= id }
+      return possible_range if possible_range && possible_range.first <= id
+    end
+    
+  end
+end

data/lib/sumac/local_reference.rb

@@ -0,0 +1,16 @@
+class Sumac
+  class LocalReference < Reference
+  
+    attr_reader :exposed_object
+    
+    def initialize(connection, exposed_id, exposed_object)
+      super(connection, exposed_id)
+      @exposed_object = exposed_object
+    end
+    
+    def remove
+      @connection.local_references.remove(self)
+    end
+    
+  end
+end

data/lib/sumac/local_references.rb

@@ -0,0 +1,80 @@
+class Sumac
+  class LocalReferences
+  
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+      @id_allocator = IDAllocator.new
+      @exposed_id_table = {}
+      @native_id_table = {}
+      @transaction = []
+    end
+    
+    def detach
+      @exposed_id_table.values.each { |reference| reference.detach }
+    end
+    
+    def destroy
+      @exposed_id_table.values.each { |reference| reference.destroy }
+    end
+    
+    def from_id(exposed_id)
+      raise unless @id_allocator.valid?(exposed_id)
+      reference = @exposed_id_table[exposed_id]
+      reference
+    end
+    
+    def from_object(exposed_object)
+      raise unless exposed_object.is_a?(ExposedObject)
+      reference = find(exposed_object) || create(exposed_object)
+      reference
+    end
+    
+    def remove(reference)
+      @exposed_id_table.delete(reference.exposed_id)
+      references = @native_id_table[reference.exposed_object.__native_id__]
+      references.delete(reference)
+      @native_id_table.delete(reference.exposed_object.__native_id__) if references.empty?
+      @id_allocator.free(reference.exposed_id)
+    end
+    
+    def rollback_transaction
+      @transaction.each { |reference| reference.quiet_forget }
+      @transaction = []
+    end
+    
+    def commit_transaction
+      @transaction = nil
+    end
+    
+    def start_transaction
+      @transaction = []
+    end
+    
+    private
+    
+    def create(exposed_object)
+      new_exposed_id = @id_allocator.allocate
+      new_reference = LocalReference.new(@connection, new_exposed_id, exposed_object)
+      @exposed_id_table[new_exposed_id] = new_reference
+      references = @native_id_table[exposed_object.__native_id__]
+      if references
+        references << new_reference
+      else
+        @native_id_table[exposed_object.__native_id__] = [new_reference]
+      end
+      @transaction << new_reference if @transaction
+      new_reference
+    end
+    
+    def find(exposed_object)
+      references = @native_id_table[exposed_object.__native_id__]
+      return nil unless references
+      callable_references = references.select { |reference| reference.callable? }
+      raise if callable_references.length > 1
+      reference = callable_references.first
+      reference
+    end
+    
+  end
+end

data/lib/sumac/message.rb

@@ -0,0 +1,19 @@
+class Sumac
+  class Message
+  
+    def self.from_json(connection, json)
+      json_structure = JSON.parse(json)
+      from_json_structure(connection, json_structure)
+    end
+    
+    def initialize(connection)
+      raise "argument 'connection' must be a Connection" unless connection.is_a?(Connection)
+      @connection = connection
+    end
+    
+    def to_json
+      to_json_structure.to_json
+    end
+    
+  end
+end

data/lib/sumac/message/exchange.rb

@@ -0,0 +1,30 @@
+class Sumac
+  class Message
+    class Exchange < Message
+    
+      def self.from_json_structure(connection, json_structure)
+        raise MessageError unless json_structure.is_a?(Hash) && json_structure['message_type'] == 'exchange'
+        exchange_class = 
+          case json_structure['exchange_type']
+          when 'compatibility_notification'
+            CompatibilityNotification
+          when 'initialization_notification'
+            InitializationNotification
+          when 'shutdown_notification'
+            ShutdownNotification
+          when 'forget_notification'
+            ForgetNotification
+          when 'call_request'
+            CallRequest
+          when 'call_response'
+            CallResponse
+          else
+            raise MessageError
+          end
+        exchange = exchange_class.from_json_structure(connection, json_structure)
+        exchange
+      end
+      
+    end
+  end
+end