pione 0.3.2 → 0.4.0

data/lib/pione/rule-engine/basic-handler.rb

@@ -57,9 +57,9 @@ module Pione
         # save domain log
         Log::DomainLog.new(self).save
 
-        # save domain info
-        domain_info_location = @working_directory ? @working_directory :@domain_location
-        System::DomainInfo.new(env.dumpable).write(domain_info_location)
+        # save a domain dump file
+        domain_dump_location = @working_directory ? @working_directory :@domain_location
+        System::DomainDump.new(env.dumpable).write(domain_dump_location)
 
         # execute the rule
         outputs = execute
@@ -67,9 +67,9 @@ module Pione
         # publish outputs and finished
         begin
           outputs.flatten.compact.each {|output| write(output)}
-          write(TupleSpace::FinishedTuple.new(@domain_id, :succeeded, outputs))
+          write(TupleSpace::FinishedTuple.new(@domain_id, Util::UUID.generate, :succeeded, outputs))
         rescue Rinda::RedundantTupleError
-          write(TupleSpace::FinishedTuple.new(@domain_id, :error, outputs))
+          write(TupleSpace::FinishedTuple.new(@domain_id, Util::UUID.generate, :error, outputs))
         end
 
         # show end message

data/lib/pione/rule-engine/engine-exception.rb

@@ -7,17 +7,18 @@ module Pione
       end
 
       def message
-        "Execution error when handling the rule '%s': inputs=%s, output=%s, params=%s" % [
-          @handler.rule.path,
+        "Execution error when handling the rule '%s': inputs=%s, output=%s, param_set=%s" % [
+          @handler.rule_name,
           @handler.inputs,
           @handler.outputs,
-          @handler.params.inspect
+          @handler.param_set
         ]
       end
     end
 
-    class ActionError < StandardError
-      def initialize(digest, report)
+    class ActionError < RuleExecutionError
+      def initialize(handler, digest, report)
+        super(handler)
         @digest = digest
         @report = report
       end
@@ -39,6 +40,6 @@ module Pione
       end
     end
 
-    class UnknownRule < StandardError; end
+    class UnknownRule < RuleExecutionError; end
   end
 end

data/lib/pione/rule-engine/flow-handler.rb

@@ -52,7 +52,11 @@ module Pione
           unless new_location == old_location or lifted.include?(old_location)
             if old_location.exist?
               # move data from old to new
-              old_location.move(new_location)
+              begin
+                old_location.turn(new_location)
+              rescue ArgumentError
+                # ignore the error because this is the case that old and new is same file
+              end
               # sync cache if the old is cached in this machine
               System::FileCache.sync(old_location, new_location)
               # write lift tuple
@@ -171,7 +175,7 @@ module Pione
       def initialize(handler)
         super(handler)
         @data_finder = DataFinder.new(tuple_space_server, domain_id)
-        @finished = [] # finished tuple cache
+        @finished = Set.new # finished tuple cache
       end
 
       # Apply input data to rules.
@@ -183,7 +187,14 @@ module Pione
         Util::Profiler.profile(Util::RuleApplicationProfileReport.new(digest)) do
           # rule application loop
           while tasks = find_tasks(rules) do
+            # save previous finished tuples's number
+            size = @finished.size
+
+            # distribute tasks
             distribute_tasks(tasks)
+
+            # check whether tasks have been processed
+            break unless size < @finished.size
           end
         end
 
@@ -419,7 +430,9 @@ module Pione
             return false
           end
           if finished = read!(template)
-            @finished << finished
+            unless @finished.any? {|t| t.uuid == finished.uuid}
+              @finished << finished
+            end
             return false
           end
         end
@@ -440,6 +453,9 @@ module Pione
           # wait to finish the distributed task, note that finished tuple is in
           # the task domain
           finished = read(TupleSpace::FinishedTuple.new(domain: task.domain_id))
+          unless @finished.any? {|t| t.uuid == finished.uuid}
+            @finished << finished
+          end
 
           ### task completion processing ###
           # copy write operation data tuple from the task domain to this domain
@@ -459,25 +475,18 @@ module Pione
       def import_outputs_of_task(task, finished)
         finished.outputs.each_with_index do |output, i|
           data_expr = task.rule_condition.outputs[i].eval(task.env)
+          output = [output] unless output.kind_of?(Array)
+
           case data_expr.operation
           when :write
-            if output.kind_of?(Array)
-              output.each {|o| copy_data_into_domain(o, domain_id)}
-            else
-              copy_data_into_domain(output, domain_id)
-            end
+            output.each {|o| copy_data_into_domain(o, domain_id)}
           when :remove
-            if output.kind_of?(Array)
-              output.each {|o| remove_data_from_domain(o, domain_id)}
-            else
-              remove_data_from_domain(output, domain_id)
-            end
+            output.each {|o| remove_data_from_domain(o, domain_id)}
           when :touch
-            if output.kind_of?(Array)
-              output.each {|o| touch_data_in_domain(o, domain_id)}
-            else
-              touch_data_in_domain(output, domain_id)
-            end
+            output.each {|o| touch_data_in_domain(o, domain_id)}
+          else
+            # here is unreached
+            raise RuleExecutionError.new(self)
           end
         end
       end

data/lib/pione/system.rb

@@ -3,12 +3,14 @@ module Pione
   end
 end
 
+require 'pione/system/system-exception'
 require 'pione/system/object'
 require 'pione/system/common'
 require 'pione/system/init'
 require 'pione/system/file-cache'
-require 'pione/system/domain-info'
+require 'pione/system/domain-dump'
 require 'pione/system/status'
+require 'pione/system/normalizer'
 
 # export some classes to the name space of Pione
 Pione.module_exec {const_set(:PioneObject, Pione::System::PioneObject)}

data/lib/pione/system/domain-dump.rb

@@ -0,0 +1,34 @@
+module Pione
+  module System
+    # `DomainDump` is a class that dumps domain environment as a file for
+    # exporting the environment from PIONE world to externals.
+    class DomainDump < StructX
+      FILENAME = ".domain.dump"
+
+      # Load the domain dump file.
+      #
+      # @param location [Location::DataLocation]
+      #   the domain dump file
+      # @return [DomainDump]
+      #   domain dump object
+      def self.load(location)
+        if location.directory?
+          location = location + FILENAME
+        end
+
+        new(Marshal.load(location.read))
+      end
+
+      member :env
+
+      # Write a domain dump file.
+      def write(location)
+        if location.directory?
+          location = location + ".domain.dump"
+        end
+
+        location.write(Marshal.dump(env.dumpable))
+      end
+    end
+  end
+end

data/lib/pione/system/file-cache.rb

@@ -10,13 +10,24 @@ module Pione
         @klass || SimpleCacheMethod
       end
 
-      # Set a file cache class.
+      # Set a file cache method.
       #
       # @param klass [Class]
       #   CacheMethod class
       # @return [void]
-      def self.set_cache_method(klass)
-        @klass = klass
+      def self.set_cache_method(file_cache_method)
+        case file_cache_method
+        when Symbol
+          if klass = @file_cache_method[file_cache_method]
+            @klass = klass
+          else
+            raise ArgumentError.new(file_cache_method)
+          end
+        when Class
+          @klass = file_cache_method
+        else
+          raise ArgumentError.new(file_cache_method)
+        end
       end
 
       # Return the singleton.
@@ -27,12 +38,14 @@ module Pione
         @instance ||= cache_method.new
       end
 
-      # Get cached data path from the uri resource.
+      # Get cached data location of the location. If the location is not cached
+      # and needs to be cached, create the cache and return it. If not, return
+      # the location as is.
       #
       # @param location [BasicLocation]
       #   data location
-      # @return [Pathname]
-      #   cached path
+      # @return [BasicLocation]
+      #   cached location
       def self.get(location)
         instance.get(location)
       end
@@ -74,8 +87,35 @@ module Pione
         instance.clear
       end
 
+      # Register the file cache method with the name.
+      #
+      # @param name [Symbol]
+      #   the name of file cache method
+      # @param klass [FileCacheMethod]
+      #   file cache method class
+      # @return [void]
+      def self.register_file_cache_method(name, klass)
+        (@file_cache_method ||= {})[name] = klass
+      end
+
       # FileCache is an interface class of cache methods.
       class FileCacheMethod
+        # Name the file cache method class.
+        #
+        # @param name [String]
+        #   cache mtehod name
+        def self.set_name(name)
+          @name = name
+          FileCache.register_file_cache_method(name, self)
+        end
+
+        # Return the name.
+        #
+        # @return [String] the name
+        def self.name
+          @name
+        end
+
         # Get the cache path of the location.
         #
         # @param location [BasicLocation]
@@ -126,6 +166,8 @@ module Pione
 
       # SimpleCacheMethod is a simple cache method implementation.
       class SimpleCacheMethod < FileCacheMethod
+        set_name :simple
+
         # Creates a method.
         def initialize
           @table = {}
@@ -135,9 +177,15 @@ module Pione
         def get(location)
           # cache if record doesn't exist
           unless @table.has_key?(location)
-            cache_location = Location[Global.file_cache_path_generator.create]
-            location.turn(cache_location)
-            @table[location] = cache_location
+            if not(location.local?)
+              # create a cache and copy the location data to it
+              cache_location = Location[Global.file_cache_path_generator.create]
+              location.copy(cache_location)
+              @table[location] = cache_location
+            else
+              # refer directly if the location is in local
+              @table[location] = location
+            end
           end
           unless @table[location].exist?
             location.turn(@table[location])
@@ -146,13 +194,19 @@ module Pione
         end
 
         def put(src, dest)
-          # make cache from source and link between cache and destination
-          @table[dest] = get(src).tap{|cache_location| cache_location.turn(dest)}
+          cache_location = @table[dest]
+
+          # update cache if
+          if cache_location.nil? or src.mtime > cache_location.mtime
+            cache_location = Location[Global.file_cache_path_generator.create]
+            src.copy(cache_location)
+            @table[dest] = cache_location
+          end
         end
 
         def sync(old_location, new_location)
-          if cache_location = @table[old_location]
-            @table[new_location] = cache_location
+          if cached?(old_location)
+            @table[new_location] = @table[old_location]
           end
         end
 
@@ -164,6 +218,31 @@ module Pione
           @table.clear
         end
       end
+
+      # NoCacheMethod is a cache method for disabling file caching.
+      class NoCacheMethod < FileCacheMethod
+        set_name :no_cache
+
+        def get(location)
+          location
+        end
+
+        def put(src, location)
+          # do nothing
+        end
+
+        def sync(old_location, new_location)
+          # do nothing
+        end
+
+        def cached?(location)
+          false
+        end
+
+        def clear
+          # do nothing
+        end
+      end
     end
   end
 end

data/lib/pione/system/init.rb

@@ -25,6 +25,9 @@ module Pione
         unless Global.file_cache_directory.exist?
           Global.file_cache_directory.mkdir(0777)
         end
+
+        # create system logger for starting on free context
+        Global.system_logger
       end
     end
   end

data/lib/pione/system/normalizer.rb

@@ -0,0 +1,40 @@
+module Pione
+  module System
+    # `Normalizer` is a utility module that normalizes values into normalization
+    # types. If values cannot normalize, this method raises
+    # `NormalizerValueError`. Normalization types are followings:
+    module Normalizer
+      class << self
+        def location(val)
+          if val.kind_of?(Location::BasicLocation)
+            val
+          else
+            Location[val]
+          end
+        rescue => e
+          raise NormalizerValueError.new(:location, val, e.message)
+        end
+
+        def param_set(val)
+          p val
+          Util.parse_param_set(val)
+        end
+
+        def nortification_address(val)
+          Notification::Address.target_address_to_uri(address.strip)
+          unless ["pnb", "pnm", "pnu"].include?(uri.scheme)
+
+          end
+        end
+      end
+    end
+  end
+end
+
+Rootage::Normalizer.set(:location) do |val|
+  Pione::System::Normalizer.location(val)
+end
+
+Rootage::Normalizer.set(:param_set) do |val|
+  Pione::System::Normalizer.param_set(val)
+end

data/lib/pione/system/status.rb

@@ -6,16 +6,16 @@ module Pione
           new(:success)
         end
 
-        def error(exception)
-          new(:error, exception)
+        def error(message)
+          new(:error, message)
         end
       end
 
-      attr_reader :exception
+      attr_reader :message
 
-      def initialize(status, exception=nil)
+      def initialize(status, message=nil)
         @status = status
-        @exception = exception
+        @message = message
       end
 
       def success?

data/lib/pione/system/system-exception.rb

@@ -1,5 +1,18 @@
 module Pione
   module System
-    class SystemException < StandardError; end
+    class SystemError < StandardError; end
+
+    # PioneBug is an error that is caused by PIONE's bug.
+    class PioneBug < SystemError
+      def initialize(message)
+        @message = message
+      end
+
+      def message
+        "[PIONE BUG] " + @message
+      end
+    end
+
+    class DomainDumpErro < SystemError; end
   end
 end