pione 0.1.2 → 0.1.3

data/lib/pione/agent/rule-provider.rb

@@ -1,11 +1,11 @@
 module Pione
   module Agent
+    # RuleProvider is an agent for providing rules to other agents.
     class RuleProvider < TupleSpaceClient
-
       set_agent_type :rule_provider
 
-      def initialize(ts_server)
-        super(ts_server)
+      def initialize(tuple_space_server)
+        super(tuple_space_server)
         @table = {}
 
         # import system rules
@@ -44,14 +44,11 @@ module Pione
       end
 
       def transit_to_rule_loading(request)
-        out = Tuple[:rule].new(rule_path: request.rule_path)
         if known_rule?(request.rule_path)
-          out.status = :known
-          out.content = @table[request.rule_path]
+          write(Tuple[:rule].new(rule_path: request.rule_path, content: @table[request.rule_path]))
         else
-          out.status = :unknown
+          processing_error("rule '%s' is unknonw" % request.rule_path)
         end
-        write(out)
       end
 
       def known_rule?(rule_path)

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

@@ -106,13 +106,11 @@ module Pione
 
       # Transition method for the state +task_waiting+. The agent takes a +task+
       # tuple and writes a +working+ tuple.
+      #
       # @return [Task]
       #   task tuple
       def transit_to_task_waiting
-        @task = nil
-        @rule = nil
         task = take(Tuple[:task].new(features: @features))
-        @task = task
         begin
           write(Tuple[:working].new(task.domain, task.digest))
           write(Tuple[:foreground].new(task.domain, task.digest))
@@ -126,23 +124,12 @@ module Pione
       # @return [Array<Task, Rule>]
       #   task tuple and the rule
       def transit_to_rule_loading(task)
-        rule =
-          begin
-            read0(Tuple[:rule].new(rule_path: task.rule_path))
-          rescue Rinda::RequestExpiredError
-            log do |msg|
-              msg.add_record(agent_type, "action", "request_rule")
-              msg.add_record(agent_type, "object", task.rule_path)
-            end
-            write(Tuple[:request_rule].new(task.rule_path))
-            read(Tuple[:rule].new(rule_path: task.rule_path))
-          end
-        @rule = rule.content
-        if rule.status == :known
-          return task, rule.content
-        else
-          raise UnknownRuleError.new(task)
+        rule = read!(Tuple[:rule].new(rule_path: task.rule_path))
+        unless rule
+          write(Tuple[:request_rule].new(task.rule_path))
+          rule = read(Tuple[:rule].new(rule_path: task.rule_path))
         end
+        return task, rule.content
       end
 
       # Transition method for the state +task_executing+.
@@ -177,13 +164,16 @@ module Pione
                 debug_message "+++ Create Sub Task worker +++"
                 @child_agent = self.class.new(tuple_space_server, @features)
                 @child_agent.once = true
-                log do |msg|
-                  msg.add_record(agent_type, "action", "create_sub_task_worker")
-                  msg.add_record(agent_type, "uuid", uuid)
-                  msg.add_record(agent_type, "object", @child_agent.uuid)
+
+                Log::CreateChildTaskWorkerProcessRecord.new.tap do |record|
+                  record.parent = uuid
+                  record.child = @child_agent.uuid
+
+                  with_process_log(record) do
+                    take!(Tuple[:foreground].new(task.domain, nil))
+                    @child_agent.start
+                  end
                 end
-                take0(Tuple[:foreground].new(task.domain, nil)) rescue true
-                @child_agent.start
               else
                 tail = descendant.last
                 if tail.action?
@@ -209,7 +199,7 @@ module Pione
         @action = nil
 
         # remove the working tuple
-        take0(Tuple[:working].new(task.domain, nil)) rescue true
+        take!(Tuple[:working].new(task.domain, nil))
 
         debug_message_end "End Task Execution #{rule.rule_path} by worker(#{uuid})"
 
@@ -245,16 +235,19 @@ module Pione
       #   the handler
       # @return [void]
       def transit_to_task_finishing(task, handler)
-        log do |msg|
-          msg.add_record(agent_type, "action", "finished_task")
-          msg.add_record(agent_type, "uuid", uuid)
-          msg.add_record(agent_type, "object", task)
-        end
+        # put finished tuple
         finished = Tuple[:finished].new(
           handler.domain, :succeeded, handler.outputs, task.digest
         )
         write(finished)
-        take0(Tuple[:foreground].new(task.domain, nil)) rescue true
+        # log task process
+        record = handler.task_process_record.merge(transition: "complete")
+        process_log(record)
+
+        # remove foreground
+        take!(Tuple[:foreground].new(task.domain, nil))
+
+        # terminate if the agent is child
         terminate if @once
       end
 

data/lib/pione/agent/tuple-space-client.rb

@@ -43,6 +43,10 @@ module Pione
         end
       end
 
+      def base_location
+        read(Tuple[:base_location].any).location
+      end
+
       # Protected take.
       def take(*args)
         tuple = super(*args, &method(:set_current_tuple_entry))
@@ -114,32 +118,36 @@ module Pione
 
       # Redefine hello method with logging.
       def hello
-        log do |msg|
-          msg.add_record(agent_type, "action", "hello")
-          msg.add_record(agent_type, "uuid", uuid)
+        record = Log::AgentConnectionProcessRecord.new.tap do |record|
+          record.agent_type = agent_type
+          record.agent_uuid = uuid
+          record.message = "hello"
         end
-        super
+        with_process_log(record) {super}
       end
 
       # Redefine bye method with logging.
       def bye
-        log do |msg|
-          msg.add_record(agent_type, "action", "bye")
-          msg.add_record(agent_type, "uuid", uuid)
+        record = Log::AgentConnectionProcessRecord.new.tap do |record|
+          record.agent_type = agent_type
+          record.agent_uuid = uuid
+          record.message = "bye"
         end
-        super
+        with_process_log(record) {super}
       end
 
-      # Redefine call transition method with logging.
+      # Override call transition method with logging.
       def call_transition_method(*args)
         unless [:logger, :command_listener].include?(agent_type)
-          log do |msg|
-            msg.add_record(agent_type, "action", "transit")
-            msg.add_record(agent_type, "state", args.first)
-            msg.add_record(agent_type, "uuid", uuid)
+          record = Log::AgentActivityProcessRecord.new.tap do |rec|
+            rec.agent_type = agent_type
+            rec.agent_uuid = uuid
+            rec.state = args.first
           end
+          with_process_log(record) {super}
+        else
+          super
         end
-        super
       end
     end
   end

data/lib/pione/command.rb

@@ -0,0 +1,21 @@
+module Pione
+  # Command is a name space for PIONE command classes.
+  module Command; end
+end
+
+require 'pione/command/basic-command'
+require 'pione/command/front-owner-command'
+require 'pione/command/daemon-process'
+require 'pione/command/child-process'
+require 'pione/command/pione-client'
+require 'pione/command/pione-task-worker'
+require 'pione/command/pione-broker'
+require 'pione/command/pione-tuple-space-provider'
+require 'pione/command/pione-tuple-space-receiver'
+require 'pione/command/pione-tuple-space-viewer'
+require 'pione/command/pione-relay'
+require 'pione/command/pione-relay-client-db'
+require 'pione/command/pione-relay-account-db'
+require 'pione/command/pione-clean'
+require 'pione/command/pione-syntax-checker'
+require 'pione/command/pione-log'

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

@@ -1,132 +1,315 @@
 module Pione
   module Command
-    # OptionInterface provides methods for defining options.
-    module ClassInterface
-      # Returns the program name.
-      def program_name
-        [@program_name, @program_name_block]
+    # CommandInfo is a strage of program informations.
+    class CommandInfo
+      attr_reader :name
+      attr_reader :tail
+      attr_reader :banner
+
+      def initialize
+        @name = nil
+        @tail = nil
+        @banner = banner
       end
 
-      # Sets progaram name and visible options.
-      def set_program_name(program_name, &b)
-        @program_name = program_name
-        @program_name_block = block_given? ? b : Proc.new{""}
+      # Set progaram name.
+      #
+      # @param name [String]
+      #   process name
+      # @param b [Proc]
+      #   process tail block
+      # @return [void]
+      def set_name(name, &b)
+        @name = name
       end
 
-      # Returns the program message.
-      def program_message
-        @program_message
+      # Set program parameters.
+      def set_tail(&tail)
+        @tail = tail
       end
 
-      # Sets program message.
-      def set_program_message(message)
-        @program_message = message
+      # Set program banner.
+      #
+      # @param banner [String]
+      #   banner message
+      # @return [void]
+      def set_banner(banner)
+        @banner = banner
       end
-    end
 
-    module InstanceInterface
       # Setup program name. If the setup process is failed, program name is not
       # changed.
       #
+      # @param cmd [BasicCommand]
+      #   command
       # @return [void]
-      def setup_program_name
-        begin
-          name, b = self.class.program_name
-          tail = self.instance_exec(&b)
-          $PROGRAM_NAME = "%s %s" % [name, tail]
-        rescue Exception
-          nil
-        end
-      end
-
-      # Returns program message.
-      # @return [String]
-      #   program message
-      def program_message
-        self.class.program_message
+      def setup(cmd)
+        $PROGRAM_NAME = "%s %s" % [@name, @tail ? @tail.call(cmd) : ""]
       end
     end
 
-    # BasicCommand is a base class for PIONE commands.
-    class BasicCommand < PioneObject
-      extend ClassInterface
-      include InstanceInterface
-      extend CommandOption::OptionInterface
-      use_option_module CommandOption::CommonOption
+    # CommandOption is a class for holding option data set.
+    class CommandOption < PioneObject
+      def_delegators :@data, :[], :[]=
 
-      # @api private
-      def self.inherited(subclass)
-        opts = command_options.clone
-        subclass.instance_eval { @command_options = opts }
-      end
-
-      # Runs the command.
-      def self.run(*args)
-        self.new(*args).run
-      end
-
-      # Runs the command.
-      def run
-        parse_options
-        validate_options
-        prepare
-        setup_program_name
-        start
+      # Creata a command option context.
+      #
+      # @param command_info [CommandInfo]
+      #   command informations
+      def initialize(command_info)
+        extend Option::OptionInterface
+        @command_info = command_info
+        @data = {}
       end
 
-      private
-
-      # Parses options.
+      # Parse the command options.
+      #
       # @return [void]
-      def parse_options
-        parser = OptionParser.new do |opt|
+      def parse
+        OptionParser.new do |opt|
+          # set banner
           opt.banner = "Usage: %s [options]" % opt.program_name
-          opt.banner << "\n" + program_message if program_message
+          opt.banner << "\n" + @command_info.banner if @command_info.banner
 
-          self.class.command_options.values.sort.each do |args, b|
-            opt.on(*args, Proc.new{|*args| self.instance_exec(*args, &b)})
-          end
+          # set version
           opt.version = Pione::VERSION
-        end
 
-        parser.parse!(ARGV)
+          # set default values
+          default_table.each do |key, value|
+            @data[key] = value
+          end
+
+          # set options
+          definitions.sort{|a,b| a.first <=> b.first}.each do |args, b|
+            opt.on(*args, Proc.new{|*args| self.instance_exec(@data, *args, &b)})
+          end
+        end.parse!(ARGV)
       rescue OptionParser::InvalidOption => e
-        e.args.each {|arg| $stderr.puts "Unknown option: #{arg}" }
+        e.args.each {|arg| $stderr.puts "Unknown option: %s" % arg }
         abort
       rescue OptionParser::MissingArgument => e
         abort(e.message)
       end
 
-      # Validates options. Override this method if subclasses should check
-      # options.
+      # Check validness of the command options.
+      #
       # @return [void]
-      def validate_options
-        # do nothing
+      def check
+        validators.each do |validator|
+          validator.call(@data)
+        end
+      end
+    end
+
+    # BasicCommand is a base class for PIONE commands.
+    class BasicCommand < PioneObject
+      @info = CommandInfo.new
+      @option = CommandOption.new(@info).tap {|x| x.use Option::CommonOption}
+      @pre_preparations = []
+      @preparations = []
+      @post_preparations = []
+      @pre_starts = []
+      @starts = []
+      @post_starts = []
+      @pre_terminations = []
+      @terminations = []
+      @post_terminations =[]
+
+      class << self
+        attr_reader :info
+        attr_reader :option
+        attr_reader :pre_preparations
+        attr_reader :preparations
+        attr_reader :post_preparations
+        attr_reader :pre_starts
+        attr_reader :starts
+        attr_reader :post_starts
+        attr_reader :pre_terminations
+        attr_reader :terminations
+        attr_reader :post_terminations
+
+        # @api private
+        def inherited(subclass)
+          parent_option = self.option
+          subclass.instance_eval do
+            @info = CommandInfo.new
+            @option = CommandOption.new(@info).tap {|x| x.use parent_option}
+          end
+          setter = lambda{|name, data| subclass.instance_variable_set(name, data.clone)}
+          setter.call(:@pre_preparations, self.pre_preparations)
+          setter.call(:@preparations, self.preparations)
+          setter.call(:@post_preparations, self.post_preparations)
+          setter.call(:@pre_starts, self.pre_starts)
+          setter.call(:@starts, self.starts)
+          setter.call(:@post_starts, self.post_starts)
+          setter.call(:@pre_terminations, self.pre_terminations)
+          setter.call(:@terminations, self.terminations)
+          setter.call(:@post_terminations, self.post_terminations)
+        end
+
+        # Define command informations.
+        #
+        # @param b [Proc]
+        #   evaluation content in the context of option definition
+        # @return [void]
+        #
+        # @example
+        #   class Cmd < BasicCommand
+        #     define_info do
+        #       set_name   "test"   # set process name
+        #       set_banner "sample" # set banner message
+        #     end
+        #   end
+        def define_info(&b)
+          @info.instance_eval(&b)
+        end
+
+        # Define command option.
+        #
+        # @param b [Proc]
+        #    context of the option definition
+        #
+        # @example
+        #   class Cmd < BasicCommand
+        #     define_option do
+        #       option("-t", "--test", "test option") do |data, arg1|
+        #         data[:test] = true
+        #       end
+        #     end
+        #   end
+        def define_option(&b)
+          @option.instance_eval(&b)
+        end
+
+        # Define a preparation process.
+        #
+        # @param type [Symbol]
+        #   preparation type
+        # @return [void]
+        def prepare(type=nil, &b)
+          case type
+          when :pre
+            @pre_preparations << b
+          when :post
+            @post_preparations << b
+          else
+            @preparations << b
+          end
+        end
+
+        # Define a start process.
+        #
+        # @param type [Symbol]
+        #   start type
+        # @return [void]
+        def start(type=nil, &b)
+          case type
+          when :pre
+            @pre_starts << b
+          when :post
+            @post_starts << b
+          else
+            @starts << b
+          end
+        end
+
+        # Define a termination process.
+        #
+        # @param type [Symbol]
+        #   termination type
+        # @return [void]
+        def terminate(type=nil, &b)
+          case type
+          when :pre
+            @pre_terminations << b
+          when :post
+            @post_terminations << b
+          else
+            @terminations << b
+          end
+        end
+
+        # Run the command.
+        #
+        # @return [void]
+        def run(*args)
+          self.new(*args).run
+        end
+      end
+
+      # Return a command option.
+      #
+      # @return [CommandOption]
+      #   command option
+      def option
+        self.class.option
       end
 
-      # Prepares for activity. Override this method if subclass should prepare
-      # before command activity.
+      # Return a command info.
+      #
+      # @return [CommandInfo]
+      #   command info
+      def info
+        self.class.info
+      end
+
+      # Run the command.
+      #
       # @return [void]
-      def prepare
+      def run
+        receiver = self
+        caller = lambda {|name| self.class.__send__(name).each{|proc| receiver.instance_eval(&proc)}}
+        caller.call(:pre_preparations)
+        caller.call(:preparations)
+        caller.call(:post_preparations)
+        caller.call(:pre_starts)
+        caller.call(:starts)
+        caller.call(:post_starts)
+        call_terminations
+      end
+
+      def call_terminations
+        receiver = self
+        caller = lambda  do |name|
+          self.class.__send__(name).reverse.each do |proc|
+            puts "%s(%s):%s:%s" % [info.name, name, *proc.source_location] if Pione.debug_mode?
+            begin
+              receiver.instance_eval(&proc)
+            rescue Object => e
+              p e
+            end
+          end
+        end
+        caller.call(:pre_terminations)
+        caller.call(:terminations)
+        caller.call(:post_terminations)
+      end
+
+      prepare(:pre) do
+        # set signal trap
         Signal.trap(:INT) do
           begin
-            terminate
+            call_terminations
           rescue DRb::ReplyReaderThreadError
             # ignore reply reader error
           end
         end
+
+        # parse options
+        option.parse
       end
 
-      # Starts the command activity. This method should be overridden in subclasses.
-      # @return [void]
-      def start
-        raise NotImplementedError
+      prepare do
+        # validate options
+        option.check
       end
 
-      # Terminate the command. Exit from PIONE system.
-      #
-      # @return [void]
-      def terminate
+      prepare(:post) do
+        # setup process name
+        info.setup(self)
+      end
+
+      terminate(:post) do
         Global.monitor.synchronize do
           # exit with no exception
           exit!