pione 0.3.1 → 0.3.2

data/example/PegasusWMS/Split/Split.pione

@@ -1,3 +1,5 @@
+.@ PackageName :: "PegasusWMS-Split"
+
 Rule Main
   output 'count.txt.*'.all
 Flow

data/example/PegasusWMS/Split/pione-package.json

@@ -0,0 +1,15 @@
+{
+  "PackageName": "PegasusWMS-Split",
+  "Parents": [
+
+  ],
+  "Documents": [
+    "Split.pione"
+  ],
+  "Scenarios": [
+
+  ],
+  "Bins": [
+
+  ]
+}

data/example/{AbstractRule/AbstractRule.pione → SelectRuleByParam/SelectRuleByParam.pione}

@@ -1,3 +1,5 @@
+.@ PackageName :: "SelectRuleByParam"
+
 Rule Main
   output 'message.txt'
   param $NAME := "A"
@@ -10,10 +12,10 @@ Flow
   when "C"
     $RULE := C
   end
-  rule Abstract {R: $RULE}
+  rule RuleSelector {R: $RULE}
 End
 
-Rule Abstract
+Rule RuleSelector
   output 'message.txt'
   param $R
 Flow

data/example/SelectRuleByParam/pione-package.json

@@ -0,0 +1,17 @@
+{
+  "PackageName": "SelectRuleByParam",
+  "Parents": [
+
+  ],
+  "Documents": [
+    "SelectRuleByParam.pione"
+  ],
+  "Scenarios": [
+    "scenario/a",
+    "scenario/b",
+    "scenario/c"
+  ],
+  "Bins": [
+
+  ]
+}

data/example/SelectRuleByParam/scenario/a/Scenario.pione

@@ -0,0 +1,2 @@
+.@ ScenarioName :: "Select A"
+.@ ParamSet :: "{NAME: \"A\"}"

data/example/SelectRuleByParam/scenario/a/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "Select A",
+  "ParamSet": "{NAME: \"A\"}",
+  "Inputs": [
+
+  ],
+  "Outputs": [
+    "output/message.txt"
+  ]
+}

data/example/SelectRuleByParam/scenario/b/Scenario.pione

@@ -0,0 +1,2 @@
+.@ ScenarioName :: "Select B"
+.@ ParamSet :: "{NAME: \"B\"}"

data/example/SelectRuleByParam/scenario/b/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "Select B",
+  "ParamSet": "{NAME: \"B\"}",
+  "Inputs": [
+
+  ],
+  "Outputs": [
+    "output/message.txt"
+  ]
+}

data/example/SelectRuleByParam/scenario/c/Scenario.pione

@@ -0,0 +1,2 @@
+.@ ScenarioName :: "Select C"
+.@ ParamSet :: "{NAME: \"C\"}"

data/example/SelectRuleByParam/scenario/c/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "Select C",
+  "ParamSet": "{NAME: \"C\"}",
+  "Inputs": [
+
+  ],
+  "Outputs": [
+    "output/message.txt"
+  ]
+}

data/example/Sum/Sum.pione

@@ -1,17 +1,19 @@
+.@ PackageName :: "Sum"
+
 Rule Main
   input 'list.txt'
   output 'sum.txt'
 Flow
-rule CalcEachLine
-rule Aggregation
+  rule CalcEachLine
+  rule Aggregation
 End
 
 Rule CalcEachLine
   input 'list.txt'
   output 'line_sum*.txt'.all
 Flow
-rule MakeHeadTail
-rule Sum
+  rule MakeHeadTail
+  rule Sum
 End
 
 Rule MakeHeadTail
@@ -19,14 +21,14 @@ Rule MakeHeadTail
   output 'head*.txt'.all
   output 'tail*.txt'.all
 Action
-#!/usr/bin/env ruby
-i = 1
-File.readlines('list.txt').each do |line|
-  head, tail = line.split(',')
-  File.open("head#{i}.txt", "w+"){|f| f.print head}
-  File.open("tail#{i}.txt", "w+"){|f| f.print tail}
-  i += 1
-end
+  #!/usr/bin/env ruby
+  i = 1
+  File.readlines('list.txt').each do |line|
+    head, tail = line.split(',')
+    File.open("head#{i}.txt", "w+"){|f| f.print head}
+    File.open("tail#{i}.txt", "w+"){|f| f.print tail}
+    i += 1
+  end
 End
 
 Rule Sum
@@ -34,19 +36,19 @@ Rule Sum
   input 'tail{$*}.txt'
   output 'line_sum{$*}.txt'.stdout
 Action
-expr `cat {$INPUT[1]}` + `cat {$INPUT[2]}`
+  expr `cat {$INPUT[1]}` + `cat {$INPUT[2]}`
 End
 
 Rule Aggregation
   input 'line_sum*.txt'.all
   output 'sum.txt'.stdout
 Action
-#!/usr/bin/env ruby
-sum = 0
-'{$INPUT[1]}'.split(':').sort.each do |filename|
-  n = File.read(filename)
-  sum += n.to_i
-  puts n
-end
-puts "total: #{sum}"
+  #!/usr/bin/env ruby
+  sum = 0
+  '{$INPUT[1]}'.split(' ').sort.each do |filename|
+    n = File.read(filename)
+    sum += n.to_i
+    puts n
+  end
+  puts "total: #{sum}"
 End

data/example/Sum/pione-package.json

@@ -0,0 +1,15 @@
+{
+  "PackageName": "Sum",
+  "Parents": [
+
+  ],
+  "Documents": [
+    "Sum.pione"
+  ],
+  "Scenarios": [
+    "scenario"
+  ],
+  "Bins": [
+
+  ]
+}

data/example/Sum/scenario/Scenario.pione

@@ -0,0 +1 @@
+.@ ScenarioName :: "test"

data/example/Sum/scenario/output/sum.txt

@@ -0,0 +1,6 @@
+45
+40
+94
+86
+98
+total: 363

data/example/Sum/scenario/pione-scenario.json

@@ -0,0 +1,10 @@
+{
+  "ScenarioName": "test",
+  "ParamSet": null,
+  "Inputs": [
+    "input/list.txt"
+  ],
+  "Outputs": [
+    "output/sum.txt"
+  ]
+}

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

@@ -48,5 +48,16 @@ module Pione
         "input generator method \"%s\" is unknown" % @name
       end
     end
+
+    # JobError is raised when job ends because of something reasons.
+    class JobError < StandardError
+      def initialize(msg)
+        @msg = msg
+      end
+
+      def message
+        @msg
+      end
+    end
   end
 end

data/lib/pione/agent/process-manager.rb

@@ -10,14 +10,18 @@ module Pione
 
       attr_reader :package
 
-      def initialize(space, env, package, param_sets, stream)
-        raise ArgumentError unless env.rule_get!(Lang::RuleExpr.new("Main"))
+      def initialize(space, env, package, param_set, stream)
+        unless env.rule_get!(Lang::RuleExpr.new("Main"))
+          raise JobError.new("Rule `Main` not found in the package.")
+        end
+
         super(space)
         @space = space
         @env = env
         @package = package
-        @param_sets = param_sets
+        @param_set = param_set
         @stream = stream
+        @package_id = @env.current_package_id
       end
 
       #
@@ -36,9 +40,17 @@ module Pione
       #
 
       def transit_to_init
+        # split parameter set as package toplvel's and main's
+        toplevel_variable_names = @env.variable_table.select_names_by(@env, @env.current_package_id)
+        toplevel_param_set = @param_set.filter(toplevel_variable_names)
+        main_param_set = @param_set.delete_all(toplevel_variable_names)
+
+        # merge the toplevel parameter set
+        @env.merge_param_set(toplevel_param_set, force: true)
+
         # setup root rule
-        definition = @env.make_root_rule(@param_sets)
-        @rule_condition = definition.rule_condition_context.eval(@env)
+        root_definition = @env.make_root_rule(main_param_set)
+        @rule_condition = root_definition.rule_condition_context.eval(@env)
 
         # share my environment
         write(TupleSpace::EnvTuple.new(@env.dumpable)) # need to be dumpable
@@ -55,10 +67,10 @@ module Pione
           user_message "error: no inputs"
           terminate
         else
+          # call root rule of the current package
           list.each do |env, inputs|
             package_id = @env.current_package_id
-            param_set = Lang::ParameterSet.new
-            handler = RuleEngine.make(@space, @env, package_id, "Root", inputs, param_set, 'root', nil)
+            handler = RuleEngine.make(@space, @env, package_id, "Root", inputs, Lang::ParameterSet.new, 'root', nil)
             handler.handle
           end
         end

data/lib/pione/agent/task-worker.rb

@@ -77,7 +77,7 @@ module Pione
         @execution_thread = Thread.new do
           begin
             engine.handle
-          rescue RuleEngine::ActionError => e
+          rescue RuleEngine::ActionError, Lang::MethodNotFound => e
             write(TupleSpace::CommandTuple.new("terminate", [System::Status.error(e)]))
             terminate
           end
@@ -115,7 +115,7 @@ module Pione
         if env = read!(TupleSpace::EnvTuple.new)
           env.obj
         else
-          raise TupleSpaceError.new("\"env\" tuple not found.")
+          raise TupleSpaceError.new("the tuple space is invalid because \"env\" tuple not found.")
         end
       end
 

data/lib/pione/command/option.rb

@@ -195,7 +195,6 @@ module Pione
           begin
             # store features
             Global.features = features
-            Global.expressional_features = Util.parse_features(features)
           rescue Parslet::ParseFailed => e
             raise OptionError.new(
               "invalid feature expression \"%s\" is given for %s" % [features, command_name]

data/lib/pione/command/pione-action-list.rb

@@ -0,0 +1,49 @@
+module Pione
+  module Command
+    # PioneActionList is a command definition of "pione action:list" for listing
+    # literate actions.
+    class PioneActionList < BasicCommand
+      #
+      # basic informations
+      #
+
+      command_name "pione action:list"
+      command_banner "show list of action names in document"
+      PioneCommand.add_subcommand("action:list", self)
+
+      #
+      # options
+      #
+
+      use_option :color
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      setup :target
+
+      # Setup location of literate action document and action name.
+      def setup_target
+        abort("There are no literate action documents or packages.")  if @argv[0].nil?
+        @location = Location[@argv[0]]
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      execute :show_list
+
+      # Show list of action names.
+      def execute_show_list
+        names = LiterateAction::Document.load(@location).action_names.sort
+        if names.empty?
+          abort("no action names in %s" % @location.address)
+        else
+          names.each {|name| puts name}
+        end
+      end
+    end
+  end
+end

data/lib/pione/command/pione-action.rb

@@ -0,0 +1,83 @@
+module Pione
+  module Command
+    # PioneAction is a command definition of "pione action" for executing
+    # literate action.
+    class PioneAction < BasicCommand
+      #
+      # basic informations
+      #
+
+      command_name "pione action"
+      command_banner "execute an action in literate action document"
+      PioneCommand.add_subcommand("action", self)
+
+      #
+      # options
+      #
+
+      use_option :color
+      use_option :debug
+
+      define_option(:domain) do |item|
+        item.long = "--domain"
+        item.desc = "use the domain information file"
+        item.default = Location["./domain.dump"]
+        item.value = lambda {|b| b}
+      end
+
+      define_option(:show) do |item|
+        item.long = "--show"
+        item.desc = "show the action without execution"
+        item.value = lambda {|b| b}
+      end
+
+      define_option(:directory) do |item|
+        item.short = "-d"
+        item.long = "--directory PATH"
+        item.desc = "execute in the PATH"
+        item.value = lambda {|b| Location[b]}
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      setup :target
+      setup :domain
+
+      # Setup location of literate action document and action name.
+      def setup_target
+        abort("There are no literate action documents or packages.")  if @argv[0].nil?
+        abort("Action name is needed.") if @argv[1].nil?
+        @location = Location[@argv[0]]
+        @name = @argv[1]
+      end
+
+      # Load a domain information file.
+      def setup_domain
+        if option[:domain].exist?
+          @domain_info = System::DomainInfo.read(option[:domain])
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      execute :exec
+
+      # Update pacakge info files.
+      def execute_exec
+        if action = LiterateAction::Document.load(@location).find(@name)
+          if option[:show]
+            puts action.textize(@domain_info)
+          else
+            action.execute(@domain_info, option[:directory])
+          end
+        else
+          abort(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/pione/command/pione-client.rb

@@ -75,10 +75,7 @@ module Pione
         item.default = Lang::ParameterSetSequence.new
         item.action = proc do |command_name, option, str|
           begin
-            stree = DocumentParser.new.parameter_set.parse(str)
-            opt = {package_name: "-", filename: "-"}
-            params = DocumentTransformer.new.apply(stree, opt)
-            option[:params].merge!(params)
+            option[:params] = option[:params].merge(Util.parse_param_set(str))
           rescue Parslet::ParseFailed => e
             raise OptionError.new("invalid parameters \"%s\" in %s" % [str, command_name])
           end
@@ -118,11 +115,17 @@ module Pione
       end
 
       define_option(:rehearse) do |item|
-        item.long = '--rehearse[=SCENARIO]'
+        item.long = '--rehearse [SCENARIO]'
         item.desc = 'rehearse the scenario'
         item.value = proc {|scenario_name| scenario_name || :anything}
       end
 
+      define_option(:timeout) do |item|
+        item.long = '--timeout SEC'
+        item.desc = 'timeout processing after SEC'
+        item.value = proc {|sec| sec.to_i}
+      end
+
       validate_option do |option|
         unless option[:task_worker] > 0 or
             (not(option[:stand_alone]) and option[:task_worker] == 0)
@@ -236,7 +239,7 @@ module Pione
         @env = Lang::Environment.new
       end
 
-      # Read a package.
+      # Read a PIONE package. This setups package sharing and secnario handling also.
       def setup_package
         # package is not found
         if @argv.first.nil?
@@ -246,12 +249,14 @@ module Pione
         # read package
         @package_handler = Package::PackageReader.read(Location[@argv.first])
         @env = @package_handler.eval(@env)
+
+        # upload the package
         @package_handler.upload(option[:output_location] + "package")
 
         # check rehearse scenario
         if option[:rehearse] and not(@package_handler.info.scenarios.empty?)
-          if scenario = @package_handler.find_scenario(option[:rehearse])
-            option[:input_location] = scenario.input
+          if @scenario_handler = @package_handler.find_scenario(option[:rehearse])
+            option[:input_location] = @scenario_handler.input
           else
             abort "the scenario not found: %s" % option[:rehearse]
           end
@@ -377,9 +382,28 @@ module Pione
 
       # Start process manager agent.
       def execute_process_manager
+        param_set = Lang::ParameterSet.new
+
+        # use paramerter set on command option
+        if option[:params] and not(option[:params].pieces.empty?)
+          param_set = option[:params].pieces.first
+        end
+
+        # use parameter set on scenario
+        if not(@scenario_handler.nil?) and @scenario_handler.info.textual_param_sets
+          param_set = Util.parse_param_set(@scenario_handler.info.textual_param_sets).pieces.first
+        end
+
+        # start
         @process_manager =
-          Agent::ProcessManager.start(@tuple_space, @env, @package_handler, option[:params], option[:stream])
-        @process_manager.wait_until_terminated(nil)
+          Agent::ProcessManager.start(@tuple_space, @env, @package_handler, param_set, option[:stream])
+        Timeout::timeout(option[:timeout]) do
+          @process_manager.wait_until_terminated(nil)
+        end
+      rescue Agent::JobError => e
+        abort(e.message)
+      rescue Timeout::Error => e
+        abort("Job timed out after %s sec." % option[:timeout])
       end
 
       # Check rehearsal result.

data/lib/pione/command/pione-compiler.rb

@@ -15,6 +15,24 @@ module Pione
 
       use_option :debug
 
+      define_option(:name) do |item|
+        item.long = '--name=NAME'
+        item.desc = 'set package name'
+        item.value = proc {|val| val}
+      end
+
+      define_option(:editor) do |item|
+        item.long = '--editor=NAME'
+        item.desc = 'set package editor'
+        item.value = proc {|val| val}
+      end
+
+      define_option(:tag) do |item|
+        item.long = '--tag=NAME'
+        item.desc = 'set package tag'
+        item.value = proc {|val| val}
+      end
+
       #
       # command lifecycle: execution phase
       #
@@ -32,7 +50,7 @@ module Pione
       execute :compile_to_pnml
 
       def execute_compile_to_pnml
-        print Util::PNMLCompiler.new(Location[@source]).compile
+        print Util::PNMLCompiler.new(Location[@source], option[:name], option[:editor], option[:tag]).compile
       end
     end
   end

data/lib/pione/command/pione-package.rb

@@ -119,6 +119,8 @@ module Pione
       # Update update info files.
       def execute_write_info
         Package::PackageHandler.write_info_files(Location[@target])
+      rescue Package::InvalidScenario => e
+        abort(e.message)
       end
 
       #

data/lib/pione/command/pione-task-worker.rb

@@ -93,7 +93,9 @@ module Pione
 
       # Create a task worker agent.
       def setup_agent
-        @agent = Agent::TaskWorker.new(@tuple_space, option[:expressive_features])
+        @agent = Agent::TaskWorker.new(@tuple_space, Global.expressional_features)
+      rescue Agent::TupleSpaceError => e
+        abort(e.message)
       end
 
       # Setup base location.

data/lib/pione/command/pione-update-package-info.rb

@@ -0,0 +1,53 @@
+module Pione
+  module Command
+    # PioneUpdatePackageInfo is a command definition of "pione
+    # update-package-info".
+    class PioneUpdatePackageInfo < BasicCommand
+      #
+      # basic informations
+      #
+
+      command_name "pione update-package-info"
+      command_banner "update package info files"
+      PioneCommand.add_subcommand("update-package-info", self)
+
+      #
+      # options
+      #
+
+      use_option :color
+      use_option :debug
+
+      define_option(:force) do |item|
+        item.long = "--force"
+        item.desc = "update pacakge info files"
+        item.value = lambda {|b| b}
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      setup :target
+
+      # Check archiver target location.
+      def setup_target
+        abort("There are no PIONE documents or packages.")  if @argv.first.nil?
+        @target = @argv.first
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      execute :update
+
+      # Update pacakge info files.
+      def execute_update
+        Package::PackageHandler.write_info_files(Location[@target], force: option[:force])
+      rescue Package::InvalidScenario => e
+        abort(e.message)
+      end
+    end
+  end
+end