pione 0.2.2 → 0.3.0

data/lib/pione/test-helper/webserver.rb

@@ -0,0 +1,50 @@
+require 'webrick'
+require 'webrick/https'
+
+module Pione
+  module TestHelper
+    class WebServer
+      class << self
+        def start(*args)
+          new(*args).tap {|x| x.start}
+        end
+      end
+
+      def initialize(document_root, option={})
+        logger = WEBrick::Log.new(StringIO.new("", "w"))
+        # modify document root
+        document_root = document_root.local.path if document_root.kind_of?(Pione::Location::DataLocation)
+
+        # setup options
+        _option = {DocumentRoot: document_root}
+        _option[:Port] = 54673 unless option[:Port]
+        _option[:Logger] = logger unless option[:Logger]
+        _option[:AccessLog] = logger unless option[:AccessLog]
+
+        # make webrick
+        @server = WEBrick::HTTPServer.new(_option)
+      end
+
+      def root
+        Pione::Location["http://localhost:%s/" % port]
+      end
+
+      def port
+        @server.config[:Port]
+      end
+
+      def start
+        @thread = Thread.new do
+          retriable(on: WEBrick::ServerError, tries: 10, interval: 2) do
+            @server.start
+          end
+        end
+      end
+
+      def terminate
+        @server.shutdown
+        @thread.kill.join
+      end
+    end
+  end
+end

data/lib/pione/tuple-space.rb

@@ -1,11 +1,9 @@
 module Pione
-  # TupleSpace is a namespace for tuple space classes.
+  # TupleSpace is a namespace for classes tuple space related.
   module TupleSpace; end
 end
 
-require 'pione/tuple-space/tuple-space-server-interface'
-require 'pione/tuple-space/presence-notifier'
+require 'pione/tuple-space/tuple-space-exception'
+require 'pione/tuple-space/basic-tuple'
+require 'pione/tuple-space/tuple-space-interface'
 require 'pione/tuple-space/tuple-space-server'
-require 'pione/tuple-space/tuple-space-receiver'
-require 'pione/tuple-space/tuple-space-provider'
-require 'pione/tuple-space/data-finder'

data/lib/pione/{tuple → tuple-space}/basic-tuple.rb

@@ -1,43 +1,21 @@
 module Pione
-  module Tuple
+  module TupleSpace
     # 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 = "Format error found in %s tuple: %s" % [@identifier, @invalid_data.inspect]
-        return msg
-      end
-    end
+    TUPLE = Hash.new
 
-    # Type represents tuple's field data type. Type has simple and complex form,
+    # TupleType represents tuple's field data type. TupleType 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 = TupleType.new(String)
     #   simple_type === "abc" #=> true
     #   # create complex type
-    #   complex_type = Type.new(String, Symbol)
+    #   complex_type = TupleType.new(String, Symbol)
     #   complex_type === "abc" #=> true
     #   complex_type === :abc  #=> true
-    class Type < PioneObject
+    class TupleType < PioneObject
       class << self
         alias :or :new
       end
@@ -83,29 +61,29 @@ module Pione
         # check arguments: format is a list of symbols
         format.each do |name, _|
           unless Symbol === name
-            raise FormatError.new(name, identifier)
+            raise TupleFormatError.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)
+        if TUPLE.has_key?(identifier)
+          if not(TUPLE[identifier].format == format)
+            raise TupleFormatError.new(format, identifier)
           else
-            return TABLE[identifier]
+            return TUPLE[identifier]
           end
         end
 
         # make a class and set it in a table
-        TABLE[identifier] = self
+        TUPLE[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)
+        if TUPLE.has_key?(identifier)
+          name = TUPLE[identifier].name.split('::').last
+          TUPLE.delete(identifier)
           remove_const(name)
         end
       end
@@ -136,7 +114,7 @@ module Pione
       #   position number of domain field, or nil
       # @api private
       def domain_position
-        position_of(:domain)
+        position_of(:domain) || position_of(:domain_id)
       end
 
       # Return location position of the format.
@@ -196,12 +174,12 @@ module Pione
           _data.keys.each do |key|
             # key check
             unless format_keys.include?(key)
-              raise FormatError.new(key, format.first)
+              raise TupleFormatError.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)
+                raise TupleFormatError.new(_data[key], format.first)
               end
             end
           end
@@ -209,14 +187,14 @@ module Pione
         else
           # length check
           unless data.size == format.size - 1
-            raise FormatError.new(data, format.first)
+            raise TupleFormatError.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)
+                raise TupleFormatError.new(data[i], format.first)
               end
             end
           end
@@ -280,6 +258,10 @@ module Pione
           @data.has_key?(symbol)
         end.unique == [true]
       end
+
+      def set(data)
+        self.class.new(@data.merge(data))
+      end
     end
 
     class << self
@@ -287,31 +269,62 @@ module Pione
       # @return [Class]
       #   tuple class
       def [](identifier)
-        TABLE[identifier]
+        TUPLE[identifier]
       end
 
       # Returns identifiers.
       # @return [Array<Symbol>]
       #   all tuple identifiers in PIONE system.
       def identifiers
-        TABLE.keys
+        TUPLE.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)
+        raise TupleFormatError.new(ary) unless ary.size > 0
+        raise TupleFormatError.new(ary) unless ary.kind_of?(Enumerable)
         _ary = ary.to_a
         identifier = _ary.first
-        raise FormatError.new(identifier) unless TABLE.has_key?(identifier)
+        raise TupleFormatError.new(identifier) unless TUPLE.has_key?(identifier)
         args = _ary[1..-1]
-        TABLE[identifier].new(*args)
+        TUPLE[identifier].new(*args)
       end
     end
 
-    # parent_agent: agent tree information
-    # define_format [:parent_agent, :parent_id, :child_id]
+    #
+    # handle tuple definition file
+    #
+
+    YAML.load_file(File.join(File.dirname(__FILE__), "tuple-definition.yml")).each do |class_name, definition|
+      klass = Class.new(BasicTuple)
+      const_set(class_name, klass)
+      format = definition.map do |d|
+        # key is field name, and value is type (value's class name)
+        if d.kind_of?(Hash)
+          [d.keys.first.to_sym, eval(d[d.keys.first])]
+        else
+          d.to_sym
+        end
+      end
+      klass.module_eval {klass.define_format(format)}
+    end
+
+    #
+    # special tuple extension
+    #
+
+    class ProcessLogTuple
+      def timestamp=(time)
+        @timestamp = time
+        message.timestamp = time
+      end
+    end
+
+    class DataTuple
+      attr_accessor :update_criteria
+      attr_accessor :accept_nonexistence
+    end
   end
 end

data/lib/pione/tuple-space/tuple-definition.yml

@@ -0,0 +1,165 @@
+#
+# tuple-definition.yml - tuple format definition file
+#
+
+# AgentTuple represents existance of agent joining the tuple space.
+AgentTuple:
+  - agent
+  - uuid       # UUID of the agent
+  - agent_type # agent type name
+
+AttributeTuple:
+  - attribute
+  - key:  # attribute name
+      "String"
+  - value # attribute value
+
+BaseLocationTuple:
+  - base_location
+  - location
+
+ByeTuple:
+  - bye
+  - uuid
+  - agent_type
+
+CommandTuple:
+  - command
+  - name
+  - args
+
+# DataNullTuple is a tuple for the situation that output data is null.
+DataNullTuple:
+  - data_null
+  - domain:   # target domain
+      String
+  - position: # output condition position
+      Integer
+
+# DataTuple is a class for input/output data.
+DataTuple:
+  - data
+  - domain:   # target domain
+      String
+  - name:     # data name
+      "TupleType.or(String, Pione::Lang::DataExprSequence)"
+  - location: # data location
+      "Pione::Location::BasicLocation"
+  - time:     # data created time
+      Time
+
+# DryRunTuple means availability of dry-run mode in the tuple space.
+DryRunTuple:
+  - dry_run
+  - availability # dry-run mode if true
+
+# EnvTuple is a tuple for sharing language environment.
+EnvTuple:
+  - env
+  - obj
+
+# exception notifier from agents
+ExceptionTuple:
+  - exception
+  - uuid       # UUID of the agent who happened the exception
+  - agent_type # agent type name
+  - value      # exception object
+
+# FinishedTuple represents task finished notifier.
+FinishedTuple:
+  - finished
+  - domain:  # task domain
+      String
+  - status:  # status of the task processing
+      Symbol
+  - outputs: # outputs
+      Array
+
+# ForegroundTuple represents the task is active (rule engine is processing it now).
+ForegroundTuple:
+  - foreground
+  - domain # domain of the task
+  - digest # digest string of the task
+
+# LiftTuple represents data movement information from old location to new
+# location.
+LiftTuple:
+  - lift
+  - old_location:
+      "Location::BasicLocation"
+  - new_location:
+      "Location::BasicLocation"
+
+MessageTuple:
+  - message
+  - type
+  - head
+  - color
+  - level
+  - contents
+
+ProcessInfoTuple:
+  - process_info
+  - name       # process name
+  - process_id # process id
+
+# ProcessLogTuple represents process event messages.
+ProcessLogTuple:
+  - process_log
+  - message:
+      "Log::ProcessRecord"
+
+# RuleTuple represents rule content.
+RuleTuple:
+  - rule
+  - rule_path # rule location path
+  - content   # rule content
+
+# TaskTuple is a class for rule application job with inputs, outpus and parameters.
+TaskTuple:
+  - task
+  - digest:     # digest
+      String
+  - package_id: # package id
+      String
+  - rule_name:  # rule name
+      String
+  - inputs:     # input data list
+      Array
+  - param_set:  # parameter set
+      "Pione::Lang::ParameterSet"
+  - features:   # request features
+      "Pione::Lang::FeatureSequence"
+  - domain_id:  # domain id of the task
+      String
+  - caller_id:  # domain id of the caller task
+      String
+
+# number of task worker for tuple space server
+TaskWorkerResourceTuple:
+  - task_worker_resource
+  - number # resource number of task workers.
+
+# TicketTuple is a tuple representation of ticket.
+TicketTuple:
+  - ticket
+  - domain
+  - ticket_name
+
+TouchTuple:
+  - touch
+  - domain: # target domain
+      String
+  - name:   # name
+      String
+  - time:   # touched time
+      Time
+
+# WorkingTuple represents current working task informations.
+WorkingTuple:
+  - working
+  - domain: # caller domain
+      String
+  - digest: # rule handler digest
+      String
+

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

@@ -0,0 +1,25 @@
+module Pione
+  module TupleSpace
+    # TupleFormatError is raised when tuple format is invalid.
+    class TupleFormatError < 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 = "Format error found in %s tuple: %s" % [@identifier, @invalid_data.inspect]
+        return msg
+      end
+    end
+  end
+end