pione 0.2.2 → 0.3.0

data/lib/pione/agent/input-generator.rb

@@ -1,155 +1,72 @@
 module Pione
   module Agent
     class InputGenerator < TupleSpaceClient
-      set_agent_type :input_generator
+      set_agent_type :input_generator, self
+      DOMAIN = "root"
 
-      InputData = Struct.new(:name, :uri, :time)
-      DOMAIN = "input"
+      @generator_method = Hash.new
 
-      # Base class for generator methods.
-      class GeneratorMethod
-        def initialize(ts_server)
-          @tuple_space_server = ts_server
-        end
-
-        def now
-          @tuple_space_server.now
-        end
-
-        # Generate an input.
-        def generate
-          raise RuntimeError
-        end
-
-        # Return true if the generator is stream.
-        # @return [Boolean]
-        #   true if the generator is stream mode
-        def stream?
-          return false
-        end
-      end
-
-      # DirGeneratorMethod is a directory based generator.
-      class DirGeneratorMethod < GeneratorMethod
-        # Create a generator.
-        #
-        # @param tuple_space_server [TupleSpaceServer]
-        #   tuple space server
-        # @param dir [BasicLocation]
-        #   input directory location
-        def initialize(tuple_space_server, dir)
-          raise Argument.new(dir) unless dir.kind_of?(Location::BasicLocation) or dir.nil?
-          super(tuple_space_server)
-          @gen = dir ? dir.file_entries.to_enum : [].each
-        end
-
-        def generate
-          item = @gen.next
-          InputData.new(item.basename, item.uri, item.mtime)
-        end
-      end
-
-      # StreamGeneratorMethod handles stream inputs.
-      class StreamGeneratorMethod < GeneratorMethod
-        def initialize(ts_server, dir)
-          raise TypeError.new(dir) unless dir.kind_of?(Location) or dir.nil?
-          super(ts_server)
-          @dir = dir
-          @table = Hash.new
-          init
-        end
-
-        def generate
-          item = @gen.next
-          if generate_new_file?(item.basename, item.mtime)
-            @table[item.basename] = item.mtime
-            return InputData.new(item.basename, item.uri, item.mtime)
-          else
-            return nil
-          end
-        end
-
-        # Initialize the generator. This method is called when root rule is
-        # requested in stream mode.
-        #
-        # @return [void]
-        def init
-          @gen = dir ? @dir.entries.to_enum : [].each
-        end
-
-        # @api private
-        def stream?
-          return true
-        end
-
-        private
-
-        # Return true if it is new file.
-        # return [Boolean]
-        #   return true if the file is new.
-        def generate_new_file?(name, mtime)
-          return false if ['.', '..'].include?(name)
-          return true unless @table.has_key?(name)
-          mtime > @table[name]
-        end
-      end
-
-      # Create a input generator agent by directory method.
-      def self.start_by_dir(ts_server, *args)
-        start(ts_server, DirGeneratorMethod.new(ts_server, *args))
+      class << self
+        attr_reader :generator_method
       end
 
-      # Create a input generator agent by stream method.
-      def self.start_by_stream(ts_server, *args)
-        start(ts_server, StreamGeneratorMethod.new(ts_server, *args))
-      end
+      #
+      # agent activity
+      #
 
-      define_state :generating
-      define_state :sleeping
-      define_state :stop_iteration
+      define_transition :generate
+      define_transition :sleep
+      define_transition :stop_iteration
 
-      define_state_transition :initialized => :generating
-      define_state_transition :generating => :generating
-      define_state_transition :stop_iteration => lambda{|agent, res|
-        agent.stream? ? :sleeping : :terminated
+      chain :init => :generate
+      chain :generate => :generate
+      chain :stop_iteration => lambda {|agent|
+        agent.generator.stream ? :sleep : :terminate
       }
-      define_state_transition :sleeping => :generating
+      chain :sleep => :init
 
       define_exception_handler StopIteration => :stop_iteration
 
+      #
+      # instance methods
+      #
+
       attr_reader :generator
+      forward :@generator, :stream?
 
       # Initialize the agent.
-      def initialize(ts_server, generator)
-        raise ArgumentError unless generator.kind_of?(GeneratorMethod)
-        super(ts_server)
-        @generator = generator
-        @inputs = []
-      end
+      def initialize(space, generator_name, input_location, stream)
+        super(space)
+        @base_location = base_location
 
-      # Return true if generator of the agent is stream type.
-      def stream?
-        @generator.stream?
+        # generator method
+        if generator_method = InputGenerator.generator_method[generator_name]
+          @generator = generator_method.new(space, input_location, stream)
+        else
+          raise UnknownInputGeneratorMethod.new(generator_name)
+        end
       end
 
-      private
+      #
+      # transitions
+      #
 
-      def transit_to_initialized
-        @base_location = base_location
+      def transit_to_init
+        @generator.init
+        @inputs = []
       end
 
-      # State generating generates a data from generator and puts it into tuple
-      # space.
-      def transit_to_generating
+      # Generate a input data tuple and put it into tuple space.
+      def transit_to_generate
         if input = @generator.generate
           # put into history
           @inputs << input
 
           # build original location
-          orig_location = Location[input.uri]
+          orig_location = input.location
 
           # build input location
-          input_location = @base_location + File.join("input", input.name)
+          input_location = @base_location + "input" + input.name
 
           # make process log record
           record = Log::PutDataProcessRecord.new.tap do |record|
@@ -165,29 +82,92 @@ module Pione
           end
 
           # put data tuple into tuple space
-          write(Tuple[:data].new(DOMAIN, input.name, input_location, input.time))
+          write(input.set(location: input_location))
         end
       end
 
       # State stop_iteration. StopIteration exception is ignored because it
       # means the input generation was completed.
       def transit_to_stop_iteration(e)
-        # start root rule
-        if not(@inputs.empty?) or not(stream?)
-          write(Tuple[:command].new("start-root-rule", nil))
+        if not(@inputs.empty?) or not(@generator.stream?)
+          write(TupleSpace::CommandTuple.new("start-root-rule", nil))
         end
-        terminate unless stream?
       end
 
-      def transit_to_sleeping
+      def transit_to_sleep
         sleep Global.input_generator_stream_check_timespan
+      end
+    end
 
-        # init stream generator
-        @generator.init
-        @inputs = []
+    # InputGeneratorMethod is an interface class for generator methods.
+    class InputGeneratorMethod
+      def self.method_name(name)
+        InputGenerator.generator_method[name] = self
+      end
+
+      attr_reader :input_location
+      attr_reader :stream
+      alias :stream? :stream
+
+      def initialize(space, input_location, stream)
+        @__space__ = space
+        @input_location = input_location
+        @stream = stream
+      end
+
+      # Return current time. The time is based on tuple space.
+      def now
+        @__space__.now
+      end
+
+      # Initialize the generator method.
+      def init
+        raise NotImplementedError
+      end
+
+      # Generate an input tuple.
+      def generate
+        raise NotImplementedError
       end
     end
 
-    set_agent InputGenerator
+    # DirGeneratorMethod is a directory based generator.
+    class DirInputGeneratorMethod < InputGeneratorMethod
+      method_name :dir
+
+      def initialize(space, input_location, stream)
+        super
+        @table ||= Hash.new
+      end
+
+      def init
+        # save entries as Enumerator
+        if input_location
+          # files in the directory
+          @enum = input_location.file_entries.to_enum
+        else
+          # no files
+          @enum = [].to_enum
+        end
+      end
+
+      def generate
+        location = @enum.next
+        if new_file?(location.basename, location.mtime)
+          @table[location.basename] = location.mtime
+          return TupleSpace::DataTuple.new(InputGenerator::DOMAIN, location.basename, location, location.mtime)
+        end
+      end
+
+      private
+
+      # Return true if it is a new file.
+      def new_file?(name, mtime)
+        # unknown file
+        return true unless @table.has_key?(name)
+        # updated file
+        return mtime > @table[name]
+      end
+    end
   end
 end

data/lib/pione/agent/job-terminator.rb

@@ -0,0 +1,38 @@
+module Pione
+  module Agent
+    # JobTerminator is an agent that terminates the target agent when
+    # "terminate" command is received.
+    class JobTerminator < TupleSpaceClient
+      set_agent_type :job_terminator, self
+
+      def initialize(space, &b)
+        super(space)
+        @action = b
+      end
+
+      #
+      # transition definitions
+      #
+
+      define_transition :wait
+      define_transition :fire
+
+      chain :init => :wait
+      chain :wait => :fire
+      chain :fire => :terminate
+
+      #
+      # transition methods
+      #
+
+      def transit_to_wait
+        read(TupleSpace::CommandTuple.new(name: "terminate"))
+      end
+
+      def transit_to_fire
+        Log::Debug.system("job terminator fires the action %s." % @action)
+        @action.call
+      end
+    end
+  end
+end

data/lib/pione/agent/logger.rb

@@ -3,63 +3,50 @@ module Pione
     # Logger is an agent for logging process events like agent activity or rule
     # process.
     class Logger < TupleSpaceClient
-      set_agent_type :logger
+      set_agent_type :logger, self
 
-      # @return [BasicLocation]
-      attr_reader :log_location
-
-      # @return [Pathname]
-      attr_reader :output_location
+      attr_reader :log_location    # location of log file
+      attr_reader :output_location # output location
 
       # Create a logger agent.
-      #
-      # @param tuple_space_server [TupleSpaceServer]
-      #   tuple space server
-      # @param location [BasicLocation]
-      #   the path to store log records
-      def initialize(tuple_space_server, location)
-        super(tuple_space_server)
+      def initialize(space, location)
+        super(space)
         @log_id = Time.now.iso8601(3)
-        @log_location = get_log_location(location)
+        @log_location = location.directory? ? location + "pione-process.log" : location
         @output_location = get_output_location
       end
 
-      define_state :initialized
-      define_state :record
-      define_state :terminated
+      #
+      # agent activities
+      #
+
+      define_transition :record
 
-      define_state_transition :initialized => :record
-      define_state_transition :record => :record
+      chain :init => :record
+      chain :record => :record
 
-      # Sleeps till the logger clears logs.
       #
-      # @param [Float]
-      #   timespan for clearing logs
-      # @return [void]
-      def wait_to_clear_logs(timespan=0.1)
-        while count_tuple(Tuple[:process_log].any) > 0
-          sleep timespan
-        end
-      end
+      # transitions
+      #
 
       # Record process_log tuples.
       def transit_to_record
         begin
-          write_records(take_all(Tuple[:process_log].any))
+          write_records(take_all(TupleSpace::ProcessLogTuple.any))
         rescue => e
           # logger is terminated at last in termination processes, so tuple space may be closed
-          ErrorReport.warn("Failed to take process logs.", self, e, __FILE__, __LINE__)
+          Log::SystemLog.warn("logger agent failed to take process logs: %s" % e.message)
           terminate
         end
       end
 
       # Copy from output to log when log and output are different.
-      def transit_to_terminated
+      def transit_to_terminate
         begin
-          write_records(take_all!(Tuple[:process_log].any))
+          write_records(take_all!(TupleSpace::ProcessLogTuple.any))
         rescue => e
           # logger is terminated at last in termination processes, so tuple space may be closed
-          ErrorReport.warn("Failed to take process logs.", self, e, __FILE__, __LINE__)
+          Log::SystemLog.warn("logger agent failed to take process logs.", self, e)
         end
         if @log_location != @output_location
           @output_location.copy(@log_location)
@@ -69,32 +56,17 @@ module Pione
 
       private
 
-      # Write records with sorting.
       #
-      # @param tuples [Array<Tuple::LogTuple>]
-      #   records
-      # @return [void]
+      # helper methods
+      #
+
+      # Write records with sorting.
       def write_records(tuples)
         tuples.sort{|a,b| a.timestamp <=> b.timestamp}.each do |tuple|
           @output_location.append tuple.message.format(@log_id) + "\n"
         end
       end
 
-      # Get the log location. If the location is a directory, log filename is
-      # "pione-process.log".
-      #
-      # @param location [BasicLocation]
-      #   location
-      # @return [BasicLocation]
-      #   log location
-      def get_log_location(location)
-        if location.directory?
-          location + "pione-process.log"
-        else
-          location
-        end
-      end
-
       # Get the output location. If the log location is not suportted append
       # writing, output location is in local filesystem.
       def get_output_location
@@ -105,7 +77,5 @@ module Pione
         end
       end
     end
-
-    set_agent Logger
   end
 end