pione 0.1.0

data/lib/pione/tuple-space/tuple-space-server-interface.rb

@@ -0,0 +1,60 @@
+module Pione
+  module TupleSpaceServerInterface
+
+    # Define tuple space operation.
+    def self.tuple_space_operation(name)
+      define_method(name) do |*args, &b|
+        @__tuple_space_server__.__send__(name, *args, &b)
+      end
+    end
+
+    # define tuple space operations
+    tuple_space_operation :read
+    tuple_space_operation :read_all
+    tuple_space_operation :take
+    tuple_space_operation :write
+    tuple_space_operation :count_tuple
+    tuple_space_operation :notify
+
+    # Return the tuple space server.
+    def tuple_space_server
+      @__tuple_space_server__
+    end
+
+    private
+
+    # Reads a tuple without waiting.
+    # @return [Tuple]
+    def read0(tuple)
+      read(tuple, 0)
+    end
+
+    # Takes a tuple without wainting.
+    # @return [Tuple]
+    def take0(tuple)
+      take(tuple, 0)
+    end
+
+    # Log a message.
+    # @return [void]
+    def log
+      msg = Log.new
+      yield msg
+      write(Tuple[:log].new(msg))
+    end
+
+    # Set tuple space server which provides operations.
+    # @return [void]
+    def set_tuple_space_server(server)
+      @__tuple_space_server__ = server
+
+      # override #to_s as it's uri because dead remote objects cause exceptions
+      # when you try to watch the object
+      if server.methods.include?(:__drburi)
+        def @__tuple_space_server__.to_s
+          __drburi
+        end
+      end
+    end
+  end
+end

data/lib/pione/tuple-space/tuple-space-server.rb

@@ -0,0 +1,156 @@
+module Pione
+  module TupleSpace
+    module TupleSpaceServerMethod
+      def self.tuple_space_interface(name, opt={})
+        define_method(name) do |*args, &b|
+          # convert tuple space form
+          _args = args.map do |obj|
+            tuple_form = obj.respond_to?(:to_tuple_space_form)
+            tuple_form ? obj.to_tuple_space_form : obj
+          end
+          # check arguments
+          if opt.has_key?(:validator)
+            opt[:validator].call(args)
+          end
+          # send a message to the tuple space
+          result = @ts.__send__(name, *_args, &b)
+          # convert the result to tuple object
+          if converter = opt[:result]
+            converter.call(result)
+          else
+            result
+          end
+        end
+      end
+
+      # Define tuple space interfaces.
+      tuple_space_interface :read, :result => lambda{|t|
+        Tuple.from_array(t).tap{|x| x.timestamp = t.timestamp}
+      }
+      tuple_space_interface :read_all, :result => lambda{|list|
+        list.map{|t|
+          Tuple.from_array(t).tap{|x| x.timestamp = t.timestamp}
+        }
+      }
+      tuple_space_interface :take, :result => lambda{|t|
+        Tuple.from_array(t).tap{|x| x.timestamp = t.timestamp}
+      }
+      tuple_space_interface :write, :validator => Proc.new {|*args|
+        args.first.writable? if args.first.kind_of?(Tuple::BasicTuple)
+      }, :result => lambda{|t|
+        # don't return raw tuple entry in PIONE
+        nil
+      }
+      tuple_space_interface :notify
+    end
+
+    class TupleSpaceServer < PioneObject
+      include DRbUndumped
+      include TupleSpaceServerMethod
+
+      attr_reader :tuple_space
+
+      def initialize(data={})
+        @__ts__ = Rinda::TupleSpace.new
+        @tuple_space = @__ts__
+        @ts = Rinda::TupleSpaceProxy.new(@__ts__)
+        def @ts.to_s;"#<Rinda::TupleSpace>" end
+
+        # check task worker resource
+        resource = data[:task_worker_resource] || 1
+        write(Tuple[:task_worker_resource].new(number: resource))
+
+        @terminated = false
+
+        # base uri
+        if data.has_key?(:base_uri)
+          uri = data[:base_uri]
+          write(Tuple[:base_uri].new(uri: uri))
+        end
+
+        # start agents
+        @client_life_checker = Agent::TupleSpaceServerClientLifeChecker.start(self)
+      end
+
+      def set_base_uri(uri)
+        write(Tuple[:base_uri].new(uri: uri))
+      end
+
+      def drburi
+        @remote_object ||= DRb.start_service(nil, self)
+        @remote_object.__drburi
+      end
+
+      def alive?
+        not(@terminated)
+      end
+
+      # Return pid
+      def pid
+        Process.pid
+      end
+
+      def now
+        Time.now
+      end
+
+      # Return common base uri of the space.
+      def base_uri
+        URI.parse(read(Tuple[:base_uri].any).uri)
+      end
+
+      # Return the worker resource size of the server.
+      def task_worker_resource
+        read(Tuple[:task_worker_resource].any).number
+      end
+
+      # Return the number of tuples matched with specified tuple.
+      def count_tuple(tuple)
+        read_all(tuple).size
+      end
+
+      # Return the current worker size of the server.
+      def current_task_worker_size
+        tuple = Tuple[:agent].any
+        tuple.agent_type = :task_worker
+        read_all(tuple).size
+      end
+
+      # Return all tuples of the tuple space.
+      def all_tuples(*args)
+        @__ts__.all_tuples(*args).compact
+      end
+
+      def task_size
+        @__ts__.task_size
+      end
+
+      def working_size
+        @__ts__.working_size
+      end
+
+      def finished_size
+        @__ts__.finished_size
+      end
+
+      def data_size
+        @__ts__.data_size
+      end
+
+      # Shutdown the server.
+      def finalize
+        @terminated = true
+        write(Tuple[:command].new("terminate", nil))
+        @client_life_checker.terminate
+        @client_life_checker.running_thread.join
+        sleep 1
+      end
+
+      alias :terminate :finalize
+
+      def inspect
+        "#<Pione::TupleSpace::TupleSpaceServer:%s>" % object_id
+      end
+    end
+  end
+end

data/lib/pione/tuple-space/update-criteria.rb

@@ -0,0 +1,96 @@
+# UpdateCriteria repesents rule application criteria.
+module Pione::UpdateCriteria
+  class << self
+    # Return true if we need to update because of no output rule.
+    # @param [Rule] rule
+    #   rule
+    # @param [Tuple::Data] inputs
+    #   input tuples
+    # @param [Tuple::Data] outputs
+    #   output tuples
+    # @param [VariableTable] vtable
+    #   variable table
+    # @return [Boolean]
+    #   true if outputs are empty
+    def no_output_rules?(rule, inputs, outputs, vtable)
+      rule.outputs.empty?
+    end
+
+    # Return true if we need to update because of lacking some ouputs.
+    # @param [Rule] rule
+    #   rule
+    # @param [Tuple::Data] inputs
+    #   input tuples
+    # @param [Tuple::Data] outputs
+    #   output tuples
+    # @param [VariableTable] vtable
+    #   variable table
+    # @return [Boolean]
+    #   true if some outputs lack
+    def not_exist_output?(rule, inputs, outputs, vtable)
+      return true if outputs.empty?
+      result = false
+      rule.outputs.each_with_index do |data_expr, i|
+        data_expr = data_expr.eval(vtable)
+        case data_expr.modifier
+        when :all
+          if outputs[i].select{|data| data_expr.match(data.name)}.empty?
+            result = true
+          end
+        when :each
+          unless data_expr.match(outputs[i].name)
+            result = true
+          end
+        end
+        break if result
+      end
+      return result
+    end
+
+    # Return true if we need to update because of newer inputs.
+    # @param [Rule] rule
+    #   rule
+    # @param [Tuple::Data] inputs
+    #   input tuples
+    # @param [Tuple::Data] outputs
+    #   output tuples
+    # @param [VariableTable] vtable
+    #   variable table
+    # @return [Boolean]
+    #   true if inputs are newer than outputs
+    def exist_newer_input?(rule, inputs, outputs, vtable)
+      # get output oldest time
+      output_oldest_time = outputs.flatten.map{|output| output.time}.sort.last
+
+      # get input last time
+      input_last_time = inputs.flatten.map{|input| input.time}.sort.last
+
+      # criteria
+      return false unless output_oldest_time
+      return false unless input_last_time
+      return output_oldest_time < input_last_time
+    end
+
+    # Returns true if we need to update.
+    # @param [Rule] rule
+    #   rule
+    # @param [Tuple::Data] inputs
+    #   input tuples
+    # @param [Tuple::Data] outputs
+    #   output tuples
+    # @param [VariableTable] vtable
+    #   variable table
+    # @return [Boolean]
+    #   true if inputs are newer than outputs
+    def satisfy?(rule, inputs, outputs, vtable)
+      CRITERIAS.any?{|name| self.send(name, rule, inputs, outputs, vtable)}
+    end
+
+    # @api private
+    CRITERIAS = [
+      :no_output_rules?,
+      :not_exist_output?,
+      :exist_newer_input?
+    ]
+  end
+end

data/lib/pione/tuple/agent-tuple.rb

@@ -0,0 +1,10 @@
+module Pione
+  module Tuple
+    # AgentTuple represents agents information in a tuple space server.
+    class AgentTuple < BasicTuple
+      #   uuid       : uuid of the agent
+      #   agent_type : agent type
+      define_format [:agent, :uuid, :agent_type]
+    end
+  end
+end

data/lib/pione/tuple/attribute-tuple.rb

@@ -0,0 +1,7 @@
+module Pione
+  module Tuple
+    class AttributeTuple < BasicTuple
+      define_format [:attribute, [:key, String], :value]
+    end
+  end
+end

data/lib/pione/tuple/base-uri-tuple.rb

@@ -0,0 +1,9 @@
+module Pione
+  module Tuple
+    # BaseURITuple represents base location information of resource.
+    class BaseURITuple < BasicTuple
+      #  base uri of all resources on the server
+      define_format [:base_uri, :uri]
+    end
+  end
+end

data/lib/pione/tuple/basic-tuple.rb

@@ -0,0 +1,317 @@
+module Pione
+  module Tuple
+    # tuple type table
+    # @api private
+    TABLE = Hash.new
+
+    # FormatError is raised when tuple format is invalid.
+    class FormatError < StandardError
+      # Creates an error.
+      # @param [Array<Object>] invalid_data
+      #   invalid data
+      # @param [Symbol] identifier
+      #   tuple identifier
+      def initialize(invalid_data, identifier=nil)
+        @invalid_data = invalid_data
+        @identifier = identifier
+      end
+
+      # Returns a message of this error.
+      # @return [String]
+      #   message string with invalid data and tuple identifier
+      # @api private
+      def message
+        msg = @invalid_data.inspect
+        msg += " in %s" % @identifier if @identifier
+        return msg
+      end
+    end
+
+    # Type represents tuple's field data type. Type has simple and complex form,
+    # the latter is consisted by types or-relation. The method +===+ is used by
+    # matching field data and type.
+    # @example
+    #   # create simple type
+    #   simple_type = Type.new(String)
+    #   simple_type === "abc" #=> true
+    #   # create complex type
+    #   complex_type = Type.new(String, Symbol)
+    #   complex_type === "abc" #=> true
+    #   complex_type === :abc  #=> true
+    class Type < PioneObject
+      class << self
+        alias :or :new
+      end
+
+      # Creates a tuple field type.
+      # @param [Array<Object>] types
+      #   tuple field types
+      def initialize(*types)
+        raise ArgumentError.new(types) unless types.size > 0
+        @types = types
+      end
+
+      # Returns true if the type is simple.
+      # @return [Boolean]
+      #   true if the type is simple, or false
+      def simple?
+        @types.size == 1
+      end
+
+      # Returns true if the type is complex.
+      # @return [Boolean]
+      #   true if the type is complex, or false
+      def complex?
+        not(simple?)
+      end
+
+      # @api private
+      def ===(other)
+        @types.find {|t| t === other}
+      end
+    end
+
+    module TupleDefinition
+      # Defines a tuple format and create a class representing it.
+      # @return [void]
+      def define_format(format)
+        raise ScriptError if @format
+        @format = format
+
+        identifier = format.first
+        set_attr_accessors
+
+        # check arguments: format is a list of symbols
+        format.each do |name, _|
+          unless Symbol === name
+            raise FormatError.new(name, identifier)
+          end
+        end
+
+        # forbid to define same identifier and different format
+        if TABLE.has_key?(identifier)
+          if not(TABLE[identifier].format == format)
+            raise FormatError.new(format, identifier)
+          else
+            return TABLE[identifier]
+          end
+        end
+
+        # make a class and set it in a table
+        TABLE[identifier] = self
+      end
+
+      # Deletes a tuple format definition.
+      # @return [void]
+      def delete_format(identifier)
+        if TABLE.has_key?(identifier)
+          name = TABLE[identifier].name.split('::').last
+          TABLE.delete(identifier)
+          remove_const(name)
+        end
+      end
+
+      # Returns tuple's format.
+      # @return [Array]
+      #   tuple's format
+      def format
+        @format
+      end
+
+      # Returns the identifier.
+      # @return [Symbol]
+      #   identifier of the tuple
+      def identifier
+        @format.first
+      end
+
+      # Returns a respresentation for matching any tuples of same type.
+      # @return [TupleObject]
+      #   a query tuple that matches any tuples has the identifier
+      def any
+        new
+      end
+
+      # Returns domain position of the format.
+      # @return [Integer, nil]
+      #   position number of domain field, or nil
+      # @api private
+      def domain_position
+        position_of(:domain)
+      end
+
+      # Returns uri position of the format.
+      # @return [Integer, nil]
+      #   position number of URI field, or nil
+      # @api private
+      def uri_position
+        position_of(:uri)
+      end
+
+      private
+
+      # Sets the tuple format and creates accessor methods.
+      # @param [Array] definition
+      #   tuple format
+      # @return [void]
+      def set_attr_accessors
+        @format.each do |key, _|
+          define_method(key) {@data[key]}
+          define_method("%s=" % key) {|val| @data[key] = val}
+        end
+      end
+
+      # @api private
+      def position_of(name)
+        @format.each_with_index do |key, i|
+          key = key.kind_of?(Array) ? key.first : key
+          return i if key == name
+        end
+        return nil
+      end
+    end
+
+    # TupleObject is a superclass for all tuple classes.
+    class BasicTuple < PioneObject
+      def self.inherited(klass)
+        klass.extend TupleDefinition
+      end
+
+      attr_accessor :timestamp
+
+      # Creates new tuple object.
+      # @param [Hash] data
+      #   tuple data
+      def initialize(*data)
+        @data = {}
+        return if data.empty?
+
+        format = self.class.format
+        format_keys = format.map{|key,_| key}
+        format_table = Hash[*format[1..-1].select{|item|
+            item.kind_of?(Array)
+          }.flatten(1)]
+        if data.first.kind_of?(Hash)
+          _data = data.first
+          _data.keys.each do |key|
+            # key check
+            unless format_keys.include?(key)
+              raise FormatError.new(key, format.first)
+            end
+            # type check
+            if _data[key] && not(format_table[key].nil?)
+              unless format_table[key] === _data[key]
+                raise FormatError.new(_data[key], format.first)
+              end
+            end
+          end
+          @data = _data
+        else
+          # length check
+          unless data.size == format.size - 1
+            raise FormatError.new(data, format.first)
+          end
+          # type check
+          data.each_with_index do |key, i|
+            if format[i+1].kind_of?(Array)
+              # type specified
+              unless format[i+1][1] === data[i] or data[i].nil?
+                raise FormatError.new(data[i], format.first)
+              end
+            end
+          end
+          @data = Hash[format_keys[1..-1].zip(data)]
+        end
+      end
+
+      # @api private
+      def ==(other)
+        return false unless self.class == other.class
+        to_tuple_space_form == other.to_tuple_space_form
+      end
+
+      alias :eql? :"=="
+
+      # @api private
+      def hash
+        @data.hash
+      end
+
+      # Returns the identifier.
+      # @return [Symbol]
+      #   tuple identifier
+      def identifier
+        self.class.identifier
+      end
+
+      # Converts the tuple to string form.
+      # @api private
+      def to_s
+        "#<#<#{self.class.name}> #{to_tuple_space_form.to_s}>"
+      end
+
+      # Convert to plain tuple form.
+      # @return [Array<Object>]
+      #   tuple data array for Rinda's tuple space
+      def to_tuple_space_form
+        self.class.format[1..-1].map{|key, _| @data[key]}.unshift(identifier)
+      end
+
+      # Converts the tuple to json form.
+      # @return [String]
+      #   json form of the tuple
+      def to_json(*a)
+        @data.merge({"tuple" => self.class.identifier}).to_json(*a)
+      end
+
+      # Returns the value of the specified position.
+      # @param [Integer] i
+      #   field position to get
+      # @return
+      #   the value
+      def value(i = 0)
+        @data[i]
+      end
+
+      # Returns true if the field writable.
+      # @return [Boolean]
+      def writable?
+        self.class.format.map do |symbol|
+          @data.has_key?(symbol)
+        end.unique == [true]
+      end
+    end
+
+    class << self
+      # Returns a tuple class corresponding to a tuple identifier.
+      # @return [Class]
+      #   tuple class
+      def [](identifier)
+        TABLE[identifier]
+      end
+
+      # Returns identifiers.
+      # @return [Array<Symbol>]
+      #   all tuple identifiers in PIONE system.
+      def identifiers
+        TABLE.keys
+      end
+
+      # Return a tuple data object converted from an array.
+      # @return [TupleObject]
+      #   tuple object
+      def from_array(ary)
+        raise FormatError.new(ary) unless ary.size > 0
+        raise FormatError.new(ary) unless ary.kind_of?(Enumerable)
+        _ary = ary.to_a
+        identifier = _ary.first
+        raise FormatError.new(identifier) unless TABLE.has_key?(identifier)
+        args = _ary[1..-1]
+        TABLE[identifier].new(*args)
+      end
+    end
+
+    # parent_agent: agent tree information
+    # define_format [:parent_agent, :parent_id, :child_id]
+  end
+end