pione 0.4.2 → 0.5.0.alpha.1

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

@@ -58,6 +58,7 @@ module Pione
         @request_from = @tuple_space.attribute("request_from")
         @session_id = @tuple_space.attribute("session_id")
         @client_ui = @tuple_space.attribute("client_ui")
+        super
       end
 
       # Take a task and turn it to foreground.
@@ -92,13 +93,7 @@ module Pione
 
         # start the engine
         @execution_thread = Thread.new do
-          begin
-            engine.handle
-          rescue RuleEngine::RuleExecutionError, Lang::LangError => e
-            user_message("ERROR: " + e.message, 0, "info", :red)
-            write(TupleSpace::CommandTuple.new(name: "terminate", args: [System::Status.error(e.message)]))
-            terminate
-          end
+          engine.handle || terminate
         end
 
         # spawn child task worker if flow

data/lib/pione/command.rb

@@ -25,6 +25,7 @@ module Pione
       require 'pione/command/pione-package-build'
       require 'pione/command/pione-package-show'
       require 'pione/command/pione-package-update'
+      require 'pione/command/pione-package-remove'
     end
   end
 end

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

@@ -37,7 +37,9 @@ module Pione
 
       # Exit the running command and return failure status. Note that this
       # method enters termination phase before it exits.
-      def abort(msg_or_exception, pos=caller(1).first)
+      def abort(msg_or_exception, option={})
+        pos = option[:pos] || caller(1).first
+
         # hide the message because some option errors are meaningless
         if msg_or_exception.is_a?(HideableOptionError)
           Log::Debug.system(msg_or_exception.message, pos)

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

@@ -4,6 +4,20 @@ module Pione
 
     # SpawnError is raised when the command failed to run.
     class SpawnError < CommandException
+      # Create a spawn error caused that child process is dead
+      #
+      # @param caller [String]
+      #   caller name
+      # @param callee [String]
+      #   callee name
+      # @param argv [Array<String>]
+      #   arguments of process call
+      # @return [SpawnError]
+      #   a spawn error
+      def self.child_process_is_dead(caller, callee, argv)
+        new(caller, callee, argv, "child process is dead")
+      end
+
       def initialize(caller, callee, argv, cause)
         @caller = caller
         @callee = callee

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

@@ -68,7 +68,10 @@ module Pione
 
         item.process do
           if action = LiterateAction::Document.load(model[:location]).find(model[:name])
-            action.execute(model[:domain_info], model[:directory])
+            action.execute(
+              domain_dump: model[:domain_dump],
+              chdir: model[:directory] || Location[Global.pwd]
+            )
           else
             cmd.abort("The action not found.")
           end

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

@@ -115,10 +115,15 @@ module Pione
         # remove PPG packages
         item.process do
           Global.ppg_package_cache_directory.each_entry do |entry|
-            unless model[:db].has_digest?(Package::PackageFilename.parse(entry.basename).digest)
-              if delete?(entry)
-                entry.delete
+            begin
+              digest = Package::PackageFilename.parse(entry.basename).digest
+              unless model[:db].has_digest?(digest)
+                if delete?(entry)
+                  entry.delete
+                end
               end
+            rescue
+              # do nothing
             end
           end
         end
@@ -141,9 +146,11 @@ module Pione
         item.process do
           test(type?("profile"))
 
-          Location[Global.profile_report_directory].each_entry do |entry|
-            if delete?(entry)
-              entry.delete
+          if (Location[Global.profile_report_directory].exist?)
+            Location[Global.profile_report_directory].each_entry do |entry|
+              if delete?(entry)
+                entry.delete
+              end
             end
           end
         end

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

@@ -102,8 +102,8 @@ module Pione
         item.long = '--params="{Var:1,...}"'
         item.desc = "Set user parameters"
 
-        item.assign do |str|
-          model[:params].merge(Util.parse_param_set(str))
+        item.assign do |params|
+          model[:params].merge(params)
         end
 
         item.exception(Parslet::ParseFailed) do |e, str|
@@ -138,7 +138,7 @@ module Pione
         item.arg  = '[SCENARIO]'
         item.desc = 'rehearse the scenario'
 
-        item.assign {|val| not(val.nil?) and val.size != 0 ? val : :anything}
+        item.assign {|val| (not(val.nil?) and val.size != 0) ? val : :anything}
       end
 
       option(:timeout) do |item|
@@ -352,7 +352,7 @@ module Pione
         item.assign(:job_terminator) do
           Agent::JobTerminator.start(model[:tuple_space]) do |status|
             if status.error?
-              cmd.abort("pione-client catched the error: %s" % status.message)
+              cmd.abort("pione-client catched the error: %s" % status.message, exception: status.exception)
             else
               cmd.terminate
             end
@@ -535,7 +535,7 @@ module Pione
 
           pscenario = test(model[:package_handler].find_scenario(model[:rehearse]))
 
-          errors = pscenario.validate(model[:base_location])
+          errors = pscenario.validate(model[:base_location] + "output")
           if errors.empty?
             Log::SystemLog.info "Rehearsal Result: Succeeded"
           else

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

@@ -74,7 +74,7 @@ module Pione
 
         item.assign(:literate_action) do
           if document = model[:literate_action_document]
-            LiterateAction::Parser.parse(Location[document].read)
+            LiterateAction::MarkdownParser.parse(Location[document].read)
           end
         end
       end

data/lib/pione/command/pione-log-format.rb

@@ -92,7 +92,7 @@ module Pione
           else
             model[:trace_filters] << Proc.new do |trace|
               trace.attributes.include?(XES.string("pione:traceType", "agent_activity")) and
-                model[:agent_types].includes?(trace.events.first.org_resource)
+                model[:agent_types].include?(trace.events.first.org_resource)
             end
           end
         end

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

@@ -126,7 +126,7 @@ module Pione
         item.process do
           arg = {name: model[:name], info: model[:info]}
           Log::SystemLog.info(
-            'Package "%{name}"%{info} was added to package database' % arg
+            'Package "%{name}"%{info} has been added to package database.' % arg
           )
         end
       end

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

@@ -63,15 +63,14 @@ module Pione
       #
 
       phase(:setup) do |seq|
-        seq << :source_locations
+        seq << :source_location
       end
 
-      setup(:source_locations) do |item|
+      setup(:source_location) do |item|
         item.desc = "Setup source locations"
 
-        item.assign(:source_locations) do
-          source = model[:source].address
-          [Location[git: source], Location[data: source]]
+        item.assign(:source_location) do
+          Location[data: model[:source].address]
         end
       end
 
@@ -87,49 +86,108 @@ module Pione
         item.desc = "Build a PPG package"
 
         item.process do
-          model[:source_locations].each do |location|
-            if ppg = try_to_archive(location)
-              Log::SystemLog.info('Package %s has been built successfully.' % ppg.address)
-              cmd.terminate
-            end
+          begin
+            ppg = build_package(model[:source_location])
+            Log::SystemLog.info('Package %s has been built successfully.' % ppg.address)
+            cmd.terminate
+          rescue => e
+            cmd.abort("PIONE has failed to build a package of %s." % model[:source_location].address, exception: e)
           end
-
-          cmd.abort("Package build has failed.")
         end
       end
     end
 
     # `PionePackageBuildContext` is a context for `pione package build`.
     class PionePackageBuildContext < Rootage::CommandContext
-      def try_to_archive(location)
+      # Build a package of the location.
+      #
+      # @param location [Location]
+      #   package directory location
+      # @return [Location]
+      #   location of the generated PPG file
+      def build_package(location)
         local_location = location.local
 
         # action documents
-        actions = local_location.entries.each_with_object(Hash.new) do |entry, actions|
+        actions = read_action_documents(local_location)
+
+        # compile
+        compile_pnml(local_location, actions)
+
+        # update
+        update_package_info(local_location)
+
+        # make archiver
+        return archive_package(local_location, model[:output])
+      end
+
+      # Read actions from action documents(files that named "*.action.md").
+      #
+      # @param location [Location]
+      #   package directory location
+      # @return [Hash{String=>String}]
+      #   relation table for rule name and the action content
+      def read_action_documents(location)
+        location.entries.each_with_object(Hash.new) do |entry, actions|
           if entry.basename.end_with?(".action.md")
-            actions.merge!(LiterateAction::Parser.parse(entry.read))
+            begin
+              actions.merge!(LiterateAction::Parser.parse(entry.read))
+            rescue
+              Log::SystemLog.fatal("Error has occured when parsing the action document %s." % entry.address)
+              raise
+            end
           end
         end
+      end
 
-        # compile
-        local_location.each_entry do |entry|
+      # Compile all PNML files in the location.
+      #
+      # @param location [Location]
+      #   package directory location
+      # @param actions [Hash{String=>String}]
+      #   relation table for rule name and the action content
+      # @return [void]
+      def compile_pnml(location, actions)
+        location.each_entry do |entry|
           if (entry.extname == ".pnml")
-            flow_name = entry.basename(".pnml")
-            net = PNML::Reader.read(entry)
-            option = {
-              :flow_name => flow_name,
-              :literate_actions => actions,
-            }
-            content = PNML::Compiler.new(net, option).compile
-            file = entry.dirname + (flow_name + ".pione")
-            file.write(content)
+            begin
+              flow_name = entry.basename(".pnml")
+              net = PNML::Reader.read(entry)
+              option = {
+                :flow_rule_name => flow_name,
+                :literate_actions => actions,
+              }
+              content = PNML::Compiler.new(net, option).compile
+              file = entry.dirname + (flow_name + ".pione")
+              file.write(content)
+            rescue
+              Log::SystemLog.fatal("Error has occured when compiling the PNML file %s." % entry.address)
+              raise
+            end
           end
         end
+      end
 
-        # update
-        Package::PackageHandler.write_info_files(local_location, force: true)
+      # Update package information file.
+      #
+      # @param location [Location]
+      #   package directory location
+      # @return [void]
+      def update_package_info(location)
+        Package::PackageHandler.write_info_files(location, force: true)
+      rescue
+        Log::SystemLog.fatal("Error has occured when updating package information file.")
+        raise
+      end
 
-        handler = Package::PackageReader.read(local_location)
+      # Update package information file.
+      #
+      # @param location [Location]
+      #   package directory location
+      # @return [Location]
+      #   location of the generated PPG file
+      def archive_package(location, output)
+        handler = Package::PackageReader.read(location)
         cache_location = Package::PackageCache.directory_cache(handler.digest)
 
         # make archiver
@@ -137,9 +195,6 @@ module Pione
 
         # archive
         return archiver.archive(model[:output], false)
-      rescue => e
-        Log::Debug.system("PIONE has failed to archive %s: %s" % [location, e.message])
-        return nil
       end
     end
 

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

@@ -0,0 +1,117 @@
+module Pione
+  module Command
+    # `PionePackageRemove` is a subcommand that removes PIONE package from package
+    # database in your system.
+    class PionePackageRemove < BasicCommand
+      #
+      # informations
+      #
+
+      define(:name, "remove")
+      define(:desc, "Remove the package from package database")
+
+      #
+      # arguments
+      #
+
+      argument(:target) do |item|
+        item.type = :string
+        item.desc = "package name that is removed from package database"
+        item.missing = "There are no package name."
+      end
+
+      #
+      # options
+      #
+
+      option(:editor) do |item|
+        item.type = :string
+        item.long = "--editor"
+        item.arg  = "NAME"
+        item.desc = "Specify editor name"
+      end
+
+      option(:tag) do |item|
+        item.type = :string
+        item.long = "--tag"
+        item.arg  = "NAME"
+        item.desc = "Specify tag name"
+      end
+
+      #
+      # command lifecycle: setup phase
+      #
+
+      phase(:setup) do |seq|
+        seq << :db
+      end
+
+      setup(:db) do |item|
+        item.desc = "Setup package database"
+
+        item.assign(:db) do
+          Package::Database.load
+        end
+      end
+
+      #
+      # command lifecycle: execution phase
+      #
+
+      phase(:execution) do |seq|
+        seq << :remove_package
+        seq << :show
+      end
+
+      execution(:remove_package) do |item|
+        item.desc = "Remove the package from package database"
+
+        item.process do
+          if model[:db].exist?(model[:target], model[:editor], model[:tag])
+            model[:db].delete(model[:target], model[:editor], model[:tag])
+            model[:db].save
+            model[:removed] = true
+          end
+        end
+      end
+
+      execution(:show) do |item|
+        item.desc = "Show the result"
+
+        item.assign(:additions) do
+          Array.new
+        end
+
+        item.process do
+          test(model[:editor])
+          model[:additions] << "editor: %s" % model[:editor]
+        end
+
+        item.process do
+          test(model[:tag])
+          model[:additions] << "tag: %s" % model[:tag]
+        end
+
+        item.assign(:info) do
+          model[:additions].size > 0 ? "(" + model[:additions].join(", ") + ")" : ""
+        end
+
+        # show log
+        item.process do
+          arg = {name: model[:target], info: model[:info]}
+          if model[:removed]
+            Log::SystemLog.info(
+              'Package "%{name}"%{info} has been removed from package database.' % arg
+            )
+          else
+            Log::SystemLog.info(
+              'Package "%{name}"%{info} not found in package database.' % arg
+            )
+          end
+        end
+      end
+    end
+
+    PionePackage.define_subcommand("remove", PionePackageRemove)
+  end
+end