pione 0.2.2 → 0.3.0

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

@@ -0,0 +1,123 @@
+module Pione
+  module TupleSpace
+    module TupleSpaceInterface
+
+      # Define tuple space operation.
+      def self.tuple_space_operation(name)
+        define_method(name) do |*args, &b|
+          @__tuple_space__.__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 :take_all
+      tuple_space_operation :write
+      tuple_space_operation :count_tuple
+      tuple_space_operation :notify
+
+      # Return the tuple space server.
+      def tuple_space_server
+        @__tuple_space__
+      end
+
+      # 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
+
+      # Take all tuples with no waiting time. If there are no matched tuples, return
+      # empty array.
+      #
+      # @param tuple [BasicTuple]
+      #   template tuple for query
+      # @return [Array<BasicTuple>]
+      #   query result
+      def take_all!(tuple)
+        begin
+          take_all(tuple, 0)
+        rescue Rinda::RequestExpiredError
+          []
+        end
+      end
+
+      # 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(TupleSpace::ProcessLogTuple.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
+      rescue DRb::DRbConnError
+        yield
+      end
+
+      # Send a processing error.
+      #
+      # @param msg [String]
+      #   error message
+      # @return [void]
+      def processing_error(msg)
+        write(TupleSpace::CommandTuple.new(name: "terminate", args: {message: msg}))
+      end
+
+      # Set tuple space server which provides operations.
+      # @return [void]
+      def set_tuple_space(server)
+        @__tuple_space__ = 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__.to_s
+            __drburi
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,21 +25,21 @@ module Pione
 
       # Define tuple space interfaces.
       tuple_space_interface :read, :result => lambda{|t|
-        Tuple.from_array(t).tap{|x| x.timestamp = t.timestamp}
+        TupleSpace.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}
+          TupleSpace.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}
+        TupleSpace.from_array(t).tap{|x| x.timestamp = t.timestamp}
       }
       tuple_space_interface :take_all, :result => lambda{|list|
-        list.map {|t| Tuple.from_array(t).tap{|x| x.timestamp = t.timestamp}}
+        list.map {|t| TupleSpace.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)
+        args.first.writable? if args.first.kind_of?(TupleSpace::BasicTuple)
       }, :result => lambda{|t|
         # don't return raw tuple entry in PIONE
         nil
@@ -65,12 +65,9 @@ module Pione
 
         # check task worker resource
         resource = data[:task_worker_resource] || 1
-        write(Tuple[:task_worker_resource].new(number: resource))
+        write(TupleSpace::TaskWorkerResourceTuple.new(number: resource))
 
         @terminated = false
-
-        # start agents
-        @client_life_checker = Agent::TupleSpaceServerClientLifeChecker.start(self)
       end
 
       # Set base location.
@@ -79,13 +76,13 @@ module Pione
       #   base location
       # @return [void]
       def set_base_location(location)
-        write(Tuple[:base_location].new(location.as_directory))
+        write(TupleSpace::BaseLocationTuple.new(location.as_directory))
       end
 
-      def drburi
-        @remote_object ||= DRb.start_service(nil, self)
-        @remote_object.__drburi
-      end
+      #def drburi
+      #  @remote_object ||= DRb.start_service(nil, self)
+      #  @remote_object.__drburi
+      #end
 
       def alive?
         not(@terminated)
@@ -105,12 +102,12 @@ module Pione
       # @return [BasicLocation]
       #   base location
       def base_location
-        read(Tuple[:base_location].any).location
+        read(TupleSpace::BaseLocationTuple.any).location
       end
 
       # Return the worker resource size of the server.
       def task_worker_resource
-        read(Tuple[:task_worker_resource].any).number
+        read(TupleSpace::TaskWorkerResourceTuple.any).number
       end
 
       # Return the number of tuples matched with specified tuple.
@@ -120,9 +117,7 @@ module Pione
 
       # 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
+        read_all(TupleSpace::AgentTuple.new(agent_type: :task_worker)).size
       end
 
       # Return all tuples of the tuple space.
@@ -147,16 +142,10 @@ module Pione
       end
 
       # Shutdown the server.
-      def finalize
+      def terminate
         @terminated = true
-        write(Tuple[:command].new("terminate", nil))
-        @client_life_checker.terminate
-        @client_life_checker.running_thread.kill
-        sleep 1
       end
 
-      alias :terminate :finalize
-
       def inspect
         "#<Pione::TupleSpace::TupleSpaceServer:%s>" % object_id
       end

data/lib/pione/util.rb

@@ -4,18 +4,23 @@ module Pione
   end
 end
 
-require 'pione/util/id'
-require 'pione/util/misc'
-require 'pione/util/waiter-table'
-require 'pione/util/error-report'
-require 'pione/util/indentation'
-require 'pione/util/uuid'
-require 'pione/util/ftp-server'
-require 'pione/util/ip-address'
-require 'pione/util/cpu'
+require 'pione/util/id'                      # ID generator
+require 'pione/util/digest'                  # Digest generator
+require 'pione/util/misc'                    # misc helper functions
+require 'pione/util/waiter-table'            # queued hash table
+require 'pione/util/indentation'             # text indentation
+require 'pione/util/uuid'                    # UUID generator
+require 'pione/util/ftp-server'              # embeded FTP server
+require 'pione/util/ip-address'              # pick up IP address
+require 'pione/util/cpu'                     # get logical core number
 require 'pione/util/variable-holdable'
 require 'pione/util/evaluatable'
 require 'pione/util/process-info'
-require 'pione/util/package-parameters-list'
-require 'pione/util/zip'
+require 'pione/util/package-parameters-list' # viewer of package parameter list
+require 'pione/util/zip'                     # zip archiver operations
+require 'pione/util/backslash-notation'      # handle backslash in text
+require 'pione/util/positionable'            # source position handler
+require 'pione/util/embeded-expr-expander'   # expand text embeded PIONE expression
+require 'pione/util/free-thread-generator'   # generate threads free from thread group
+require 'pione/util/parslet-extension'       # parslet extension
 

data/lib/pione/util/backslash-notation.rb

@@ -0,0 +1,11 @@
+module Pione
+  module Util
+    module BackslashNotation
+      class << self
+        def apply(s)
+          s.to_s.gsub(/\\(.)/){$1}
+        end
+      end
+    end
+  end
+end

data/lib/pione/util/digest.rb

@@ -0,0 +1,71 @@
+module Pione
+  module Util
+    module TaskDigest
+      def self.generate(package_id, rule_name, inputs, param_set)
+        case inputs.flatten.size
+        when 0
+          _inputs = ""
+        when 1, 2, 3
+          _inputs = inputs.flatten.map{|t| t.name}.join(",")
+        else
+          _inputs = "%s,..." % inputs.flatten[0..2].map{|i| i.name}.join(",")
+        end
+        _param_set = param_set.filter(["I", "INPUT", "O", "OUTPUT", "*"])
+        _param_set = _param_set.map{|k,v| "%s:%s" % [k, v.textize]}.join(",")
+        "&%s:%s([%s],{%s})" % [package_id, rule_name, _inputs, _param_set]
+      end
+    end
+
+    module PackageDigest
+      class << self
+        # Generate a MD5 digest of the PPG archive.
+        def generate(location)
+          case Package::PackageTypeClassifier.classify(location)
+          when :archive
+            generate_from_ppg(location)
+          when :directory
+            generate_from_directory_package(location)
+          else
+            nil
+          end
+        end
+
+        # Generate a MD5 digest of the directory package.
+        def generate_from_directory_package(location)
+          files = []
+
+          # package files
+          package_info = Package::PackageScanner.scan(location)
+          files << "pione-package.json"
+          files += package_info.filepaths
+
+          # scenario files
+          scenario_infos = package_info.scenarios.map do |scenario|
+            files << File.join(scenario, "pione-scenario.json")
+            files += Package::ScenarioScanner.scan(location + scenario).filepaths.map do |path|
+              File.join(scenario, path)
+            end
+          end
+
+          # make seed string for digest
+          seed = files.sort.each_with_object("") do |filepath, string|
+            digest = Digest::MD5.file((location + filepath).path).to_s
+            string << "%s %s\n" % [filepath, digest]
+          end
+
+          return Digest::MD5.hexdigest(seed)
+        end
+
+        # Generate a MD5 digest of the PPG archive.
+        def generate_from_ppg(location)
+          local_location = location.local
+          tmp = Temppath.create
+          ::Zip::File.open(local_location.path.to_s) do |zip|
+            zip.extract(".digest", tmp)
+          end
+          Location[tmp].read
+        end
+      end
+    end
+  end
+end

data/lib/pione/util/embeded-expr-expander.rb

@@ -0,0 +1,23 @@
+module Pione
+  module Util
+    module EmbededExprExpander
+      # Expand embeded expressions in the string.
+      def self.expand(env, str)
+        return nil if str.nil?
+
+        # parse and transform
+        tree = Lang::InterpolatorParser.new.parse(str)
+        list = Lang::InterpolatorTransformer.new.apply(tree, {package_name: nil, filename: nil})
+
+        # evaluate and join
+        list.map do |elt|
+          if elt.is_a?(String)
+            elt
+          else
+            elt.eval(env).call_pione_method(env, "textize", []).value
+          end
+        end.join("")
+      end
+    end
+  end
+end

data/lib/pione/util/evaluatable.rb

@@ -13,8 +13,11 @@ module Pione
       #   the result of evaluation
       def val!(str, domain_info=nil)
         domain_info = load_domain_info unless domain_info
-        vtable = domain_info.variable_table
-        DocumentTransformer.new.apply(DocumentParser.new.expr.parse(str)).eval(vtable)
+        env = domain_info.env
+        option = {package_name: env.current_package_id, filename: "pione-eval"}
+        Lang::DocumentTransformer.new.apply(
+          Lang::DocumentParser.new.expr.parse(str), option
+        ).eval(env)
       end
 
       # Evaluate the string as a PIONE expression and get the result value as a textized string.
@@ -27,8 +30,8 @@ module Pione
       #   the result of evaluation as an embeddable string
       def val(str, domain_info=nil)
         domain_info = load_domain_info unless domain_info
-        vtable = domain_info.variable_table
-        val!(str, domain_info).call_pione_method(vtable, "textize").first.value
+        env = domain_info.env
+        val!(str, domain_info).call_pione_method(env, "textize", []).first.value
       end
 
       private
@@ -37,9 +40,9 @@ module Pione
       def load_domain_info
         location = Location["./.domain.dump"]
         if location.exist?
-          DomainInfo.read(location)
+          System::DomainInfo.read(location)
         else
-          DomainInfo.new(VariableTable.new)
+          System::DomainInfo.new(Lang::Environment.new)
         end
       end
     end

data/lib/pione/util/free-thread-generator.rb

@@ -0,0 +1,46 @@
+module Pione
+  module Util
+    # FreeThreadGenerator provides the function that creates new threads under
+    # main thread group. This is useful for escaping threadgroup encloser.
+    module FreeThreadGenerator
+      @queue = Queue.new                        # task queue
+      @method_lock = Mutex.new                  # method lock
+      @mutex = Mutex.new                        # generator lock
+      @cv_response = ConditionVariable.new      # response cv
+      @cv_bye = ConditionVariable.new           # bye client cv
+      @__generated__ = nil                      # generated thread(temporary variable)
+
+      # Generate a thread with the block under default thread group.
+      def self.generate(&b)
+        @method_lock.synchronize do
+          @mutex.synchronize do
+            @queue.push(b)
+            @cv_response.wait(@mutex)
+            thread = @__generated__
+            @__generated__ = nil
+            @cv_bye.signal
+            return thread
+          end
+        end
+      end
+
+      private
+
+      # Start to run a loop for creating threadgroup free thread.
+      def self.create_free_thread
+        while true
+          b = @queue.pop
+          @mutex.synchronize do
+            @__generated__ = Thread.new(&b)
+            @cv_response.signal
+            @cv_bye.wait(@mutex)
+          end
+        end
+      end
+
+      # we should wait interpret +create_free_thread+ method...
+
+      @thread = Thread.new {create_free_thread} # a thread under default thread group
+    end
+  end
+end