pione 0.1.2 → 0.1.3

data/lib/pione/system/global.rb

@@ -109,26 +109,81 @@ module Pione
         Global.dot_pione_dir + "config.yml"
       end
 
-      # root of working directory
-      define_item(:working_directory_root, true) do
-        Pathname.new(File.join(Dir.tmpdir, "pione-wd-" + Etc.getlogin)).tap {|path|
-          path.mkpath unless path.exist?
-        }
+      # @!method temporary_directory_root
+      #
+      # Temporary directory's root path. You can change temporary directories
+      # paths by setting this variable.
+      #
+      # @return [Pathname]
+      #   root of all temporary directories
+      #
+      # @example
+      #   Global.temporary_directory_root #=> "/tmp/pione"
+      define_item(:temporary_directory_root, true, Pathname.new(Dir.tmpdir) + "pione")
+
+      # @!method temporary_directory
+      #
+      # Temporary directory for various processings.
+      #
+      # @return [Pathname]
+      #   temporary directory
+      #
+      # @example
+      #   Global.temporary_directory #=> "/tmp/pione/misc_keita"
+      define_item(:temporary_directory, false) do
+        Global.temporary_directory_root + "misc_%s" % Etc.getlogin
       end
 
-      # working directory
+      # @!method working_directory_root
+      #
+      # Root of working directory. This directory is created by each user.
+      #
+      # @return [Pathname]
+      #   root of working directory
+      #
+      # @example
+      #   Global.working_directory_root #=> "/tmp/pione/working_keita"
+      define_item(:working_directory_root, false) do
+        dir = Global.temporary_directory_root + "working_%s" % Etc.getlogin
+        Pathname.new(dir).tap {|path| path.mkpath unless path.exist?}
+      end
+
+      # @!method working_directory
+      #
+      # Working directory for action rules.
+      #
+      # @return [Pathname]
+      #   working directory
+      #
+      # @example
+      #   Global.working_directory #=> "/tmp/pione/working_keita/d20130404-10000-1kg2ezo"
       define_item(:working_directory, false) do
         Pathname.new(Dir.mktmpdir(nil, Global.working_directory_root))
       end
 
-      # root of file cache directory
-      define_item(:file_cache_directory_root, true) do
-        Pathname.new(File.join(Dir.tmpdir, "pione-file-cache-" + Etc.getlogin)).tap {|path|
-          path.mkpath unless path.exist?
-        }
+      # @!method file_cache_directory_root
+      #
+      # Root of file cache directory. This directory is created by each user.
+      #
+      # @return [Pathname]
+      #   root of file cache directory
+      #
+      # @example
+      #   Global.file_cache_directory_root #=> "/tmp/pione/file-cache_keita"
+      define_item(:file_cache_directory_root, false) do
+        dir = Global.temporary_directory_root + "file-cache_%s" % Etc.getlogin
+        Pathname.new(dir).tap {|path| path.mkpath unless path.exist?}
       end
 
-      # file cache directory
+      # @!method file_cache_directory
+      #
+      # File cache directory.
+      #
+      # @return [Pathname]
+      #   file cache directory
+      #
+      # @example
+      #   Global.file_cache_directory #=> "/tmp/pione/file-cache_keita/d20130404-11086-qtu7h0"
       define_item(:file_cache_directory, false) do
         Pathname.new(Dir.mktmpdir(nil, Global.file_cache_directory_root))
       end

data/lib/pione/system/init.rb

@@ -8,6 +8,26 @@ module Pione
         # load configration file
         System::Config.load(Global.config_path)
 
+        # make temporary directories
+        unless Global.temporary_directory_root.exist?
+          Global.temporary_directory_root.mkdir(0777)
+        end
+        unless Global.temporary_directory.exist?
+          Global.temporary_directory.mkdir(0700)
+        end
+        unless Global.working_directory_root.exist?
+          Global.working_directory_root.mkdir(0777)
+        end
+        unless Global.working_directory.exist?
+          Global.working_directory.mkdir(0700)
+        end
+        unless Global.file_cache_directory_root.exist?
+          Global.file_cache_directory_root.mkdir(0777)
+        end
+        unless Global.file_cache_directory.exist?
+          Global.file_cache_directory.mkdir(0700)
+        end
+
         # relay client database
         Global.relay_client_db = Relay::RelayClientDB.new(Global.relay_client_db_path)
 

data/lib/pione/transformer/expr-transformer.rb

@@ -55,7 +55,7 @@ module Pione
       rule(:message =>
         { :message_name => simple(:name),
           :message_parameters => sequence(:parameters) }) {
-        OpenStruct.new(name, parameters)
+        OpenStruct.new(name: name, parameters: parameters)
       }
 
       # Transform +:message+ with parameters as OpenStruct.
@@ -65,6 +65,11 @@ module Pione
         OpenStruct.new(name: name, parameters: arg)
       }
 
+      # data null
+      rule(:data_null => simple(:obj)) {
+        Model::DataExprNull.instance
+      }
+
       # Extract the content of +:rule_expr+.
       rule(:rule_expr => simple(:rule)) { rule }
 

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

@@ -55,18 +55,31 @@ module Pione
     private
 
     # Finds all data tuples by the expression from a tuple space server.
+    #
     # @param [DataExpr] expr
     #   query expression of data
     # @return [DataFinderResult]
     #   query result
-    # @api private
     def find_by_expr(expr)
       expr = DataExpr.new(expr) if expr.kind_of?(String)
       query = Tuple[:data].new(name: expr, domain: @domain)
-      return tuple_space_server.read_all(query)
+      return tuple_space_server.read_all(query).map do |tuple|
+        tuple.update_criteria = expr.update_criteria; tuple
+      end
     end
 
     # Find input tuple combinatioins recursively.
+    #
+    # @param type [Symbol]
+    #   input or output
+    # @param exprs [Array<DataExpr>]
+    #   data expressions
+    # @param index
+    #   index
+    # @param vtable [VariableTable]
+    #   variable table
+    # @return [Array<DataFinderResult>]
+    #   the result
     def find_rec(type, exprs, index, vtable)
       # return empty when we reach the recuirsion end
       return [DataFinderResult.new([], vtable)] if exprs.empty?
@@ -78,12 +91,17 @@ module Pione
       # find an input data by name from tuple space server
       tuples = find_by_expr(head)
 
+      # the case for accepting noexistance data
+      if tuples.empty? and head.accept_nonexistence?
+        return find_rec_sub(type, tail, index, tuples, vtable)
+      end
+
       # make combination results
       prefix = (type == :input ? "I" : "O")
       if head.all?
         # case all modifier
         new_vtable =
-          make_auto_variables_by_all(prefix, head, tuples, vtable)
+          make_auto_variables_by_all(prefix, head, tuples, vtable, index)
         unless tuples.empty?
           return find_rec_sub(type, tail, index, tuples, new_vtable)
         end
@@ -111,7 +129,7 @@ module Pione
 
     # Make auto-variables by the name modified 'all'.
     # @api private
-    def make_auto_variables_by_all(prefix, expr, tuples, vtable)
+    def make_auto_variables_by_all(prefix, expr, tuples, vtable, index)
       # create new table
       new_vtable = VariableTable.new(vtable)
       # variable
@@ -123,16 +141,25 @@ module Pione
       io_list = RuleIOList.new
       new_vtable.set!(var, list.add(io_list))
 
+      asterisk = []
+
       # convert each tuples
       tuples.each do |tuple, i|
+        asterisk << expr.match(tuple.name).to_a[1]
+
         elt = RuleIOElement.new(PioneString.new(tuple.name))
-        elt.uri = PioneString.new(tuple.uri)
+        elt.uri = PioneString.new(tuple.location.uri)
         elt.match = PioneList.new(
           *expr.match(tuple.name).to_a.map{|m| PioneString.new(m)}
         )
         io_list.add!(elt)
       end
 
+      # set special variable if index equals 1
+      if prefix == 'I' && index == 1
+        new_vtable.set(Variable.new("*"), PioneString.new(asterisk.join(":")))
+      end
+
       return new_vtable
     end
 
@@ -150,7 +177,7 @@ module Pione
       list = new_vtable.get(var)
       list = RuleIOList.new unless list
       elt = RuleIOElement.new(PioneString.new(tuple.name))
-      elt.uri = PioneString.new(tuple.uri)
+      elt.uri = PioneString.new(tuple.location.uri.to_s)
       elt.match = PioneList.new(*md.map{|d| PioneString.new(d)})
       new_vtable.set!(var, list.add(elt))
 

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

@@ -46,7 +46,6 @@ module Pione
 
       # Send empty tuple space server list.
       def finalize
-        puts "finalize"
         @terminated = true
         @tuple_space_server_receiver.terminate
         @socket.close
@@ -124,8 +123,10 @@ module Pione
               broker.update_tuple_space_servers(tuple_space_servers)
               true
             rescue Exception => e
-              puts "[[[dead server]]]"
-              ErrorReport.print(e)
+              if Pione.debug_mode?
+                puts "[[[dead server]]]"
+                ErrorReport.print(e)
+              end
               false
             end
           end

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

@@ -23,24 +23,69 @@ module Pione
 
     private
 
-    # Reads a tuple without waiting.
-    # @return [Tuple]
-    def read0(tuple)
-      read(tuple, 0)
+    # Read a tuple with no waiting time. If there are no matched tuples, return
+    # +nil+.
+    #
+    # @param tuple [BasicTuple]
+    #   template tuple for query
+    # @return [BasicTuple, nil]
+    #   query result
+    def read!(tuple)
+      begin
+        read(tuple, 0)
+      rescue Rinda::RequestExpiredError
+        nil
+      end
+    end
+
+    # Take a tuple with no waiting time. If there are no matched tuples, return
+    # +nil+.
+    #
+    # @param tuple [BasicTuple]
+    #   template tuple for query
+    # @return [BasicTuple, nil]
+    #   query result
+    def take!(tuple)
+      begin
+        take(tuple, 0)
+      rescue Rinda::RequestExpiredError
+        nil
+      end
     end
 
-    # Takes a tuple without wainting.
-    # @return [Tuple]
-    def take0(tuple)
-      take(tuple, 0)
+    # Put a log tuple with the data as a process record into tuple space. The
+    # record's value of transition is "complete" by default and the timestamp
+    # set automatically.
+    #
+    # @param record [Log::ProcessRecord]
+    #   process log record
+    # @return [void]
+    def process_log(record)
+      record = record.merge(transition: "complete") unless record.transition
+      write(Tuple[:log].new(record))
+    end
+
+    # Do the action with loggging.
+    #
+    # @param record [Log::ProcessRecord]
+    #   process log record
+    # @yield
+    #   the action
+    # @return [void]
+    def with_process_log(record)
+      process_log(record.merge(transition: "start"))
+      result = yield
+      process_log(record.merge(transition: "complete"))
+      return result
     end
 
-    # Log a message.
+    # Send a processing error.
+    #
+    # @param msg [String]
+    #   error message
     # @return [void]
-    def log
-      msg = Log.new
-      yield msg
-      write(Tuple[:log].new(msg))
+    def processing_error(msg)
+      write(Tuple[:command].new(name: "terminate", args: {message: msg}))
     end
 
     # Set tuple space server which provides operations.

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

@@ -62,18 +62,17 @@ module Pione
 
         @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))
+      # Set base location.
+      #
+      # @param location [BasicLocation]
+      #   base location
+      # @return [void]
+      def set_base_location(location)
+        write(Tuple[:base_location].new(location.as_directory))
       end
 
       def drburi
@@ -94,9 +93,12 @@ module Pione
         Time.now
       end
 
-      # Return common base uri of the space.
-      def base_uri
-        URI.parse(read(Tuple[:base_uri].any).uri)
+      # Return common base location of the space.
+      #
+      # @return [BasicLocation]
+      #   base location
+      def base_location
+        read(Tuple[:base_location].any).location
       end
 
       # Return the worker resource size of the server.

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

@@ -60,7 +60,7 @@ module Pione::UpdateCriteria
     #   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
+      output_oldest_time = outputs.flatten.select{|output| output.update_criteria == :care}.map{|output| output.time}.sort.last
 
       # get input last time
       input_last_time = inputs.flatten.map{|input| input.time}.sort.last
@@ -71,23 +71,24 @@ module Pione::UpdateCriteria
       return output_oldest_time < input_last_time
     end
 
-    # Returns true if we need to update.
+    # Return true if we need to update.
+    #
     # @param [Rule] rule
     #   rule
-    # @param [Tuple::Data] inputs
+    # @param [Tuple::DataTuple] inputs
     #   input tuples
-    # @param [Tuple::Data] outputs
+    # @param [Tuple::DataTuple] 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)}
+      CRITERIA.any?{|name| self.send(name, rule, inputs, outputs, vtable)}
     end
 
-    # @api private
-    CRITERIAS = [
+    # PIONE data update criteria
+    CRITERIA = [
       :no_output_rules?,
       :not_exist_output?,
       :exist_newer_input?

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

@@ -0,0 +1,9 @@
+module Pione
+  module Tuple
+    # BaseLocationTuple represents base location for processing results.
+    class BaseLocationTuple < BasicTuple
+      #  base location of all resources on the server
+      define_format [:base_location, :location]
+    end
+  end
+end

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

@@ -21,8 +21,7 @@ module Pione
       #   message string with invalid data and tuple identifier
       # @api private
       def message
-        msg = @invalid_data.inspect
-        msg += " in %s" % @identifier if @identifier
+        msg = "Format error found in %s tuple: %s" % [@identifier, @invalid_data.inspect]
         return msg
       end
     end
@@ -140,12 +139,13 @@ module Pione
         position_of(:domain)
       end
 
-      # Returns uri position of the format.
-      # @return [Integer, nil]
-      #   position number of URI field, or nil
+      # Return location position of the format.
+      #
+      # @return [Integer or nil]
+      #   position number of location field, or nil
       # @api private
-      def uri_position
-        position_of(:uri)
+      def location_position
+        position_of(:location)
       end
 
       private