pione 0.4.2 → 0.5.0.alpha.1

data/lib/pione/pnml/pnml-model.rb

@@ -70,7 +70,13 @@ module Pione
       # @return [Array<Arc>]
       #   result arcs
       def find_all_arcs_by_source_id(source_id)
-        arcs.select {|arc| arc.source_id == source_id}
+        _arcs = arcs.select {|arc| arc.source_id == source_id}
+
+        if block_given?
+          _arcs.each {|arc| yield arc}
+        else
+          return _arcs
+        end
       end
 
       # Find all arcs by the target ID.
@@ -80,7 +86,13 @@ module Pione
       # @return [Array<Arc>]
       #   result arcs
       def find_all_arcs_by_target_id(target_id)
-        arcs.select {|arc| arc.target_id == target_id}
+        _arcs = arcs.select {|arc| arc.target_id == target_id}
+
+        if block_given?
+          _arcs.each {|arc| yield arc}
+        else
+          return _arcs
+        end
       end
 
       # Return all arcs which have the direction from transtion to place.
@@ -88,7 +100,13 @@ module Pione
       # @return [Array<PNML::Arc>]
       #   arcs
       def tp_arcs
-        arcs.select {|arc| arc.from_transition_to_place?}
+        _arcs = arcs.select {|arc| arc.from_transition_to_place?}
+
+        if block_given?
+          _arcs.each {|arc| yield arc}
+        else
+          return _arcs
+        end
       end
 
       # Return all arcs which have the direction from place to transition.
@@ -96,7 +114,13 @@ module Pione
       # @return [Array<PNML::Arc>]
       #   arcs
       def pt_arcs
-        arcs.select {|arc| arc.from_place_to_transition?}
+        _arcs = arcs.select {|arc| arc.from_place_to_transition?}
+
+        if block_given?
+          _arcs.each {|arc| yield arc}
+        else
+          return _arcs
+        end
       end
 
       # Find a transition by ID.
@@ -116,7 +140,7 @@ module Pione
       # @return [Transition]
       #   a transition, or nil
       def find_transition_by_name(name)
-        _transitions = transitions.select {|transition| transition.name == name}
+        _transitions = find_all_transitions_by_name(name)
 
         # the result shouldn't be ambiguous
         if _transitions.size > 1
@@ -133,7 +157,13 @@ module Pione
       # @return [Array<Transition>]
       #   transitions
       def find_all_transitions_by_name(name)
-        transitions.select {|transition| transition.name == name}
+        _transitions = transitions.select {|transition| transition.name == name}
+
+        if block_given?
+          _transitions.each {|transition| yield transition}
+        else
+          return _transitions
+        end
       end
 
       # Find a transition by the source place ID.
@@ -143,10 +173,7 @@ module Pione
       # @return [Array<Transition>]
       #   result transitions
       def find_transition_by_source_id(place_id)
-        _arcs = arcs.select {|arc| arc.source_id == place_id}
-        _transitions = _arcs.map do |arc|
-          transitions.find {|transition| transition.id == arc.target_id}
-        end.compact.uniq
+        _transitions = find_all_transitions_by_source_id(place_id)
 
         # the result shouldn't be ambiguous
         if _transitions.size > 1
@@ -166,8 +193,13 @@ module Pione
         _arcs = arcs.select {|arc| arc.source_id == place_id}
         _transitions = _arcs.map do |arc|
           transitions.find {|transition| transition.id == arc.target_id}
+        end.compact.uniq
+
+        if block_given?
+          _transitions.each {|transition| yield transition}
+        else
+          return _transitions
         end
-        return _transitions.compact.uniq
       end
 
       # Find a transition by the target place ID.
@@ -176,11 +208,8 @@ module Pione
       #   place ID
       # @return [Array<Transition>]
       #   result transitions
-      def find_transition_by_target_id(target_id)
-        _arcs = arcs.select {|arc| arc.target_id == target_id}
-        _transitions = _arcs.map do |arc|
-          transitions.find {|transition| transition.id == arc.source_id}
-        end.compact.uniq
+      def find_transition_by_target_id(place_id)
+        _transitions = find_all_transitions_by_target_id(place_id)
 
         # the result shouldn't be ambiguous
         if _transitions.size > 1
@@ -200,8 +229,13 @@ module Pione
         _arcs = arcs.select {|arc| arc.target_id == target_id}
         _transitions = _arcs.map do |arc|
           transitions.find {|transition| transition.id == arc.source_id}
+        end.compact.uniq
+
+        if block_given?
+          _transitions.each {|transition| yield transition}
+        else
+          return _transitions
         end
-        return _transitions.compact.uniq
       end
 
       # Find a place by ID.
@@ -221,7 +255,7 @@ module Pione
       # @return [Place]
       #   a place, or nil
       def find_place_by_name(name)
-        _places = places.select {|place| place.name == name}
+        _places = find_all_places_by_name(name)
 
         # the result shouldn't be ambiguous
         if _places.size > 1
@@ -238,7 +272,13 @@ module Pione
       # @return [Array<Place>]
       #   places
       def find_all_places_by_name(name)
-        places.select {|place| place.name == name}
+        _places = places.select {|place| place.name == name}
+
+        if block_given?
+          _places.each {|place| yield place}
+        else
+          return _places
+        end
       end
 
       # Find a place by the source transition ID.
@@ -248,10 +288,7 @@ module Pione
       # @return [Array<Transition>]
       #   a result place
       def find_place_by_source_id(transition_id)
-        _arcs = arcs.select {|arc| arc.source_id == transition_id}
-        _places = _arcs.map do |arc|
-          places.find {|place| place.id == arc.target_id}
-        end.compact.uniq
+        _places = find_all_places_by_source_id(transition_id)
 
         # the result shouldn't be ambiguous
         if _places.size > 1
@@ -271,8 +308,13 @@ module Pione
         _arcs = arcs.select {|arc| arc.source_id == transition_id}
         _places = _arcs.map do |arc|
           places.find {|place| place.id == arc.target_id}
+        end.compact.uniq
+
+        if block_given?
+          _places.each {|place| yield place}
+        else
+          return _places
         end
-        return _places.compact.uniq
       end
 
       # Find a place by the target transition ID.
@@ -282,10 +324,7 @@ module Pione
       # @return [Array<Transition>]
       #   result places
       def find_place_by_target_id(transition_id)
-        _arcs = arcs.select {|arc| arc.target_id == transition_id}
-        _places = _arcs.map do |arc|
-          places.find {|place| place.id == arc.source_id}
-        end.compact.uniq
+        _places = find_all_places_by_target_id(transition_id)
 
         # the result shouldn't be ambiguous
         if _places.size > 1
@@ -305,25 +344,18 @@ module Pione
         _arcs = arcs.select {|arc| arc.target_id == transition_id}
         _places = _arcs.map do |arc|
           places.find {|place| place.id == arc.source_id}
+        end.compact.uniq
+
+        if block_given?
+          _places.each {|place| yield place}
+        else
+          return _places
         end
-        return _places.compact.uniq
       end
     end
 
     # `Node` is a meta class for `Place` and `Transition`.
     class Node < StructX
-      # Eliminate comments from the string. This implementation is temporary, we
-      # should fix this.
-      def eliminate_comment(str)
-        # FIXME
-        str.sub(/#.*$/, "")
-      end
-
-      # Return true if the name is empty.
-      def empty_name?
-        name.nil? or /^\s*[<>]?\s*$/.match(eliminate_comment(name))
-      end
-
       def inspect
         "#<%s id=%s name=%s>" % [self.class.name, id.inspect, name.inspect]
       end

data/lib/pione/pnml/ticket-instantiation.rb

@@ -0,0 +1,42 @@
+module Pione
+  module PNML
+    # TicketInstantiation is a net rewriting rule for ticket operation
+    # ">>>". This rule replaces anonymous ticket operations into named tickets.
+    # Net like this
+    #
+    #    A --> >>> --> B
+    #
+    # is replaced
+    #
+    #    A --> ticket <__TICKET_FROM_A_TO_B__> --> B
+    #
+    module TicketInstantiation
+      TICKET_NAME = "__TICKET_FROM_%s_TO_%s__"
+
+      def self.find_subjects(net, env)
+        net.places.each do |place|
+          next unless place.name.strip == ">>>"
+
+          net.find_all_transitions_by_target_id(place.id) do |transition_from|
+            net.find_all_transitions_by_source_id(place.id) do |transition_to|
+              return [transition_from, transition_to, place]
+            end
+          end
+        end
+
+        return nil
+      end
+
+      # Rewrite the net with subjects by the following way.
+      #
+      # - Change the place name
+      def self.rewrite(net, subjects, env)
+        transition_from, transition_to, place = subjects
+        name_from = Perspective.normalize_rule_name(transition_from.name)
+        name_to = Perspective.normalize_rule_name(transition_to.name)
+
+        place.name = "<%s>" % (TICKET_NAME % [name_from, name_to])
+      end
+    end
+  end
+end

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

@@ -7,24 +7,46 @@ module Pione
       end
 
       attr_reader :working_directory
+      attr_reader :shell_script
 
       def initialize(param)
         super(param)
-        @working_directory = Location[Global.working_directory_generator.mkdir]
-        @env.variable_set(
-          Lang::Variable.new("__WORKING_DIRECTORY__"),
-          Lang::StringSequence.of(@working_directory.path.to_s)
-        )
+
+        @working_directory = WorkingDirectory.new(@env, @base_location, @inputs)
+        @shell_script = ActionShellScript.new(@env, @working_directory, @rule_definition, @dry_run)
       end
 
       # Execute the action.
       def execute
         # prepare input files
-        setup_working_directory
-        # prepare shell script
-        write_shell_script {|path| call_shell_script(path)}
+        @working_directory.import
+
+        # call shell script
+        sh = @shell_script.write
+        user_message(["-"*60, sh.split("\n"), "-"*60].flatten, 0, "SH")
+        result = @shell_script.call(@sesstion_id, @request_from, @client_ui)
+        unless result
+          # the case the script has errored
+          raise ActionError.new(self, @digest, @shell_script.stderr.read)
+        end
+
+        # handle stdout mode of outputs
+        copy_stdout_to_outputs(@shell_script.stdout)
+
         # collect outputs
-        outputs = collect_outputs
+        output_conditions = @rule_condition.outputs.map {|condition| condition.eval(@env)}
+        outputs = @working_directory.collect_outputs(output_conditions).map.with_index do |names, i|
+          tuples = names.map {|name| make_output_tuple_with_time(name)}
+
+          # apply touch operation
+          apply_touch_operation(output_conditions[i], tuples) || tuples
+        end
+
+        # write data null if needed
+        outputs.each_with_index do |output, i|
+          write_data_null(output_conditions[i], outputs[i], i)
+        end
+
         # write output data
         write_output_data(outputs)
         # write tuples
@@ -35,25 +57,131 @@ module Pione
         write_other_resources
 
         # clear working directory
-        @working_directory.delete
+        @working_directory.close
 
         # return tuples
         return outputs
       end
 
-      # Setup the variable table with working directory in addition.
-      def setup_variable_table
-        super
+      # Make output tuple by name.
+      def make_output_tuple_with_time(name)
+        time = (@working_directory.location + name).mtime
+        location = make_output_location(name)
+        TupleSpace::DataTuple.new(name: name, domain: @domain_id, location: location, time: time)
+      end
+
+      # Copy stdout file in the working directory to outputs.
+      #
+      # @param stdout [Location]
+      #   stdout file
+      # @return [void]
+      def copy_stdout_to_outputs(stdout)
+        if stdout.exist?
+          @rule_condition.outputs.map do |output|
+            condition = output.eval(@env)
+            if condition.output_mode == :stdout
+              condition.pieces.each do |piece|
+                stdout.copy(@working_directory.location + piece.pattern)
+              end
+            end
+          end
+        end
+      end
+
+      # Write output data with caching.
+      #
+      # @return [void]
+      def write_output_data(outputs)
+        outputs.flatten.compact.each do |output|
+          src = @working_directory.location + output.name
+          dest = output.location
+          System::FileCache.put(src, dest)
+          # copy the data to the caller's domain in file server
+          src.copy(dest)
+        end
+      end
+
+      # Write action environment information file.
+      def write_env_info
+        @env.variable_table.keys.map do |var|
+          val = @env.variable_get(var)
+          "%s: %s" % [var.name, val.textize]
+        end.tap {|x| (@working_directory.location + ".pione-env").create(x.join("\n"))}
+      end
 
-        @variable_table.set(Variable.new("__BASE__"), PioneString.new(base_location.uri).to_seq)
-        @variable_table.set(Variable.new("_"), PackageExprSequence.new([PackageExpr.new(@rule.package_name)]))
+      # Move other intermediate files to the domain location.
+      def write_other_resources
+        @working_directory.location.file_entries.each do |entry|
+          location = make_location(entry.path.basename, @domain_id)
+          begin
+            entry.move(location)
+          rescue => e
+            Log::SystemLog.warn("cannot move %s to %s: %s" % [entry.path, location, e.message])
+          end
+        end
+      end
+
+      # Writes output tuples into the tuple space server.
+      def write_output_tuples(outputs)
+        outputs.flatten.compact.each {|output| write(output)}
+      end
+    end
+
+    # WorkingDirectory is a directory that action rule executes the shell script.
+    class WorkingDirectory
+      def initialize(env, base_location, inputs)
+        @env = env
+        @dir = Location[Global.working_directory_generator.mkdir]
+        @base_location = base_location
+        @inputs = inputs
+      end
+
+      def location
+        @dir
       end
 
       # Synchronize input data into working directory.
-      def setup_working_directory
+      def import
+        @env.variable_set(
+          Lang::Variable.new("__WORKING_DIRECTORY__"),
+          Lang::StringSequence.of(@dir.path.to_s)
+        )
+
+        import_inputs
+        import_bins
+        import_etc
+      end
+
+      # Collect output data by names from working directory.
+      #
+      # @param output_conditions [Condition]
+      #   all output conditions of action rule
+      # @return [Array<Array<String>>]
+      #   array of output filenames
+      def collect_outputs(output_conditions)
+        filenames = @dir.file_entries.map{|entry| entry.basename}
+        output_conditions.map do |condition|
+          case condition.distribution
+          when :all
+            filenames.select{|name| condition.match?(name)}
+          when :each
+            name = filenames.find {|name| condition.match?(name)}
+            name ? [name] : []
+          end
+        end
+      end
+
+      # Clear the working directory.
+      def close
+        @dir.delete
+      end
+
+      private
+
+      def import_inputs
         @inputs.flatten.each do |input|
           # get file path in working directory
-          wd_location = @working_directory + input.name
+          wd_location = @dir + input.name
           # create a link to cache
           cache_location = System::FileCache.get(input.location)
           wd_location.path.make_symlink(cache_location.path)
@@ -61,12 +189,14 @@ module Pione
             raise RuleExecutionError.new(self)
           end
         end
+      end
 
+      def import_bins
         # FIXME: should not copy bin files in the package each time.
         bin = @base_location + "package" + "bin"
         if bin.exist?
           bin.entries.each do |entry|
-            dest = @working_directory + "bin" + entry.basename
+            dest = @dir + "bin" + entry.basename
             unless dest.exist?
               # copy and set executable flag
               entry.copy(dest)
@@ -74,12 +204,14 @@ module Pione
             end
           end
         end
+      end
 
+      def import_etc
         # FIXME: should not copy files in the package each time
         file_dir = @base_location + "package" + "etc"
         if file_dir.exist?
           file_dir.entries.each do |entry|
-            dest = @working_directory + "etc" + entry.basename
+            dest = @dir + "etc" + entry.basename
             unless dest.exist?
               # copy and unset executable flag
               entry.copy(dest)
@@ -88,147 +220,92 @@ module Pione
           end
         end
       end
+    end
+
+    # ActionShellScript handles action rule's shell script.
+    class ActionShellScript
+      attr_reader :location
+
+      def initialize(env, working_directory, rule_definition, dry_run)
+        @env = env
+        @working_directory = working_directory
+        @rule_definition = rule_definition
+        @dry_run = dry_run
+        @location = @working_directory.location + "__pione__.sh"
+      end
 
-      # Write the action into a shell script.
-      def write_shell_script(&b)
-        file = @working_directory + "__pione__.sh"
+      # Write the rule action into a shell script.
+      #
+      # @return [String]
+      #   written shell script
+      def write
         content = @rule_definition.action_context.eval(@env).content
         sh = Util::EmbededExprExpander.expand(@env, content)
 
         # write the action
         if @dry_run
-          @rule.outputs.flatten.each do |output|
-            file.create("touch %s" % output.eval(@env).name)
+          rule_condition = @rule_definition.rule_condition_context.eval(@env)
+          rule_definition.outputs.flatten.each do |output|
+            @location.append("touch %s" % output.eval(@env).pieces.first.pattern)
           end
         else
-          file.create(sh)
-
-          # chmod 700
-          if @working_directory.scheme == "local"
-            FileUtils.chmod(0700, file.path)
-          end
+          @location.create(sh)
         end
 
-        # message
-        user_message(["-"*60, sh.split("\n"), "-"*60].flatten, 0, "SH")
+        # chmod 700
+        if @working_directory.location.scheme == "local"
+          FileUtils.chmod(0700, @location.path)
+        end
 
-        return b.call(file.path)
+        return sh
       end
 
-      # Call shell script of the path.
-      def call_shell_script(path)
-        scriptname = File.basename(path)
-
-        # stdout & stderr
-        rule_condition = @rule_definition.rule_condition_context.eval(@env)
-        output_conditions = rule_condition.outputs.map {|output| output.eval(@env)}
-        stdout = output_conditions.find{|output| output.output_mode == :stdout}
-        out = stdout ? stdout.pieces.first.pattern : ".stdout"
-        err = ".stderr"
-
-        # execute command
-        # `cd #{}; PATH=#{(@working_directory + "bin").path}:$PATH; ./#{scriptname} > #{out} 2> #{err}`
+      # Call the shell script.
+      #
+      # @param session_id [String]
+      #   session id
+      # @param request_from [String]
+      #   address of the client that task requested
+      # @param client_ui [String]
+      #   UI type of the client
+      # @return [void]
+      def call(session_id, request_from, client_ui)
         callee_env = {
-          "PATH" => (@working_directory + "bin").path.to_s + ";" + ENV["PATH"],
-          "PIONE_SESSION_ID" => @session_id,
-          "PIONE_REQUEST_FROM" => @request_from.to_s,
-          "PIONE_CLIENT_UI" => @client_ui.to_s
+          "PATH" => (@working_directory.location + "bin").path.to_s + ":" + ENV["PATH"],
+          "PIONE_SESSION_ID" => session_id,
+          "PIONE_REQUEST_FROM" => request_from.to_s,
+          "PIONE_CLIENT_UI" => client_ui.to_s
         }
-        command = "./#{scriptname} > #{out} 2> #{err}"
-        options = {:chdir => @working_directory.path.to_s}
+        command = "./#{@location.basename} > #{stdout.basename} 2> #{stderr.basename}"
+        options = {:chdir => @working_directory.location.path.to_s}
 
+        # execute command
         system(callee_env, command, options)
 
-        # the case the script has errored
-        unless $?.success?
-          raise ActionError.new(self, digest, (@working_directory + err).read)
-        end
-
-        # delete .stdout file if it is empty
-        if stdout.nil? and (@working_directory + out).size == 0
-          (@working_directory + out).delete
-        end
-
-        # delete .stderr file if it is emtpy
-        if (@working_directory + err).size == 0
-          (@working_directory + err).delete
+        result = $?.success?
+        if result
+          # delete .stderr and .stdout files if they are empty
+          stdout.delete if stdout.size == 0
+          stderr.delete if stderr.size == 0
         end
+        return result
+      #end
       end
 
-      # Make output tuple by name.
-      def make_output_tuple_with_time(name)
-        time = (@working_directory + name).mtime
-        location = make_output_location(name)
-        TupleSpace::DataTuple.new(name: name, domain: @domain_id, location: location, time: time)
-      end
-
-      # Collect output data by names from working directory.
+      # Return the location of stdout file.
       #
-      # @return [void]
-      def collect_outputs
-        outputs = []
-        filenames = @working_directory.file_entries.map{|entry| entry.path.basename.to_s}
-        @rule_condition.outputs.each_with_index do |condition, i|
-          _condition = condition.eval(@env)
-          case _condition.distribution
-          when :all
-            outputs[i] = filenames.select{|name| _condition.match?(name)}.map do |name|
-              make_output_tuple_with_time(name)
-            end
-          when :each
-            if name = filenames.find {|name| _condition.match?(name)}
-              outputs[i] = [make_output_tuple_with_time(name)]
-            end
-          end
-
-          # apply touch operation
-          if tuple = apply_touch_operation(_condition, outputs[i])
-            outputs[i] = tuple
-          end
-
-          # write data null if needed
-          write_data_null(_condition, outputs[i], i)
-        end
-
-        return outputs
+      # @return [Location]
+      #   location of stdout file
+      def stdout
+        @working_directory.location + ".stdout"
       end
 
-      # Write output data with caching.
+      # Return the location of stderr file.
       #
-      # @return [void]
-      def write_output_data(outputs)
-        outputs.flatten.compact.each do |output|
-          src = @working_directory + output.name
-          dest = output.location
-          System::FileCache.put(src, dest)
-          # copy the data to the caller's domain in file server
-          src.copy(dest)
-        end
-      end
-
-      # Write action environment information file.
-      def write_env_info
-        @env.variable_table.keys.map do |var|
-          val = @env.variable_get(var)
-          "%s: %s" % [var.name, val.textize]
-        end.tap {|x| (@working_directory + ".pione-env").create(x.join("\n"))}
-      end
-
-      # Move other intermediate files to the domain location.
-      def write_other_resources
-        @working_directory.file_entries.each do |entry|
-          location = make_location(entry.path.basename, @domain_id)
-          begin
-            entry.move(location)
-          rescue => e
-            Log::SystemLog.warn("cannot move %s to %s: %s" % [entry.path, location, e.message])
-          end
-        end
-      end
-
-      # Writes output tuples into the tuple space server.
-      def write_output_tuples(outputs)
-        outputs.flatten.compact.each {|output| write(output)}
+      # @return [Locaiton]
+      #   location of stderr file
+      def stderr
+        @working_directory.location + ".stderr"
       end
     end
   end