pione 0.3.2 → 0.4.0

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

@@ -0,0 +1,7 @@
+module Pione
+  module TaskWorkerBroker
+  end
+end
+
+require 'pione/task-worker-broker/basic-provider'
+require 'pione/task-worker-broker/easy-provider'

data/lib/pione/task-worker-broker/basic-provider.rb

@@ -0,0 +1,20 @@
+module Pione
+  module TaskWorkerBroker
+    # `BasicProvider` is an abstract class for task worker providers.
+    class BasicProvider
+      # @param model [Model::TaskWorkerBrokerModel]
+      #   model of task worker broker
+      def initialize(model)
+        @model = model
+      end
+
+      # Execute task worker provisioning. If this method returned true, broker
+      # executes retry provision transition with no span. If false, broker
+      # sleeps a little.
+      def provide
+        raise NotImplementedError
+      end
+    end
+  end
+end
+

data/lib/pione/task-worker-broker/easy-provider.rb

@@ -0,0 +1,65 @@
+module Pione
+  module TaskWorkerBroker
+    # `EasyProvider` is a task worker provider by blancing ratios of tuple space
+    # and task worker.
+    class EasyProvider < BasicProvider
+      # Balance task worker ratio by creating a new task worker in minimum
+      # tuple space or killing a task worker in maximum.
+      def provide
+        ratios = calc_resource_ratios
+        min = ratios.values.min
+        max = ratios.values.max
+        min_server = ratios.key(min)
+        max_server = ratios.key(max)
+
+        return false unless min_server
+        return false unless max_server
+
+        if @model.excess_task_workers > 0 and min_server
+          return @model.create_task_worker(min_server)
+        else
+          return adjust_task_worker(min_server, max_server)
+        end
+      end
+
+      # Calculate resource ratios of tuple space servers.
+      def calc_resource_ratios(revision={})
+        ratio = {}
+        # make ratio table
+        @model.tuple_space_lock.synchronize do
+          @model.tuple_spaces.each do |tuple_space|
+            rev = revision.has_key?(tuple_space) ? revision[tuple_space] : 0
+            current = timeout(1){tuple_space.current_task_worker_size} + rev
+            resource = tuple_space.task_worker_resource
+            # minimum resource is 1
+            resource = 1 unless resource > 0
+            ratio[tuple_space] = current / resource.to_f
+          end
+        end
+        return ratio
+      end
+
+      # Adjusts task worker size between tuple space servers.
+      def adjust_task_worker(min_server, max_server)
+        revision = {min_server => 1, max_server => -1}
+        new_ratios = calc_resource_ratios(revision)
+
+        # failed to calculate tuple space ratio
+        return unless new_ratios.has_key?(min_server)
+        return unless new_ratios.has_key?(max_server)
+
+        # kill a task worker for moving worker from max server to min server
+        if new_ratios[min_server] < new_ratios[max_server]
+          if @model.terminate_task_worker_if do |worker|
+            worker.tuple_space == max_server && worker.states.any?{|s| s.current?(:take_task)}
+          end
+            return true
+          end
+        end
+
+        # failed to adjust task workers
+        return false
+      end
+    end
+  end
+end

data/lib/pione/test-helper.rb

@@ -1,10 +1,29 @@
 # This file should be loaded in spec files only.
 
 require 'bacon'
+require 'erb'
 require 'pione'
+require 'rootage/test-helper'
+
+Pione::Command.load_all
 
 Pione::Global.git_package_directory = Pione::Location[Temppath.mkdir]
 
+Pione::Global.define_internal_item(:project_root) do |item|
+  item.init = Pione::Location[File.dirname(__FILE__)] + ".." + ".."
+end
+
+Pione::Global.define_internal_item(:test_start_time) do |item|
+  item.init = Time.now
+end
+
+Pione::Global.define_internal_item(:test_report) do |item|
+  item.define_updater do
+    filename = Pione::Global.test_start_time.strftime("test-report.txt")
+    Pione::Global.project_root + filename
+  end
+end
+
 module Pione
   module TestHelper
     DIR = Location[File.dirname(__FILE__)]
@@ -45,6 +64,14 @@ class Bacon::Context
   include Pione
   include Pione::TestHelper::TransformerInterface
   include Pione::TupleSpace::TupleSpaceInterface
+
+  alias :orig_it :it
+  def it(desc, &b)
+    time = Time.now
+    orig_it(desc, &b)
+    line = "[%s] %s: %s\n" % [@name, desc, (Time.now - time).round(3)]
+    Pione::Global.test_report.append(line)
+  end
 end
 
 # init

data/lib/pione/test-helper/command-helper.rb

@@ -1,94 +1,5 @@
 module Pione
   module TestHelper
-    # CommandResult is a result of command execution. This has result status,
-    # stdout, stdin, and etc, so you can analyze and check it.
-    class CommandResult < StructX
-      member :exception
-      member :stdout
-      member :stderr
-
-      # Return true if the command succeeded.
-      def success?
-        exception.kind_of?(SystemExit) and exception.success?
-      end
-
-      # Print the command result report.
-      def report
-        unless success?
-          puts "[FAIL]"
-          puts "ERROR: %s" % exception.message
-          exception.backtrace.each do |line|
-            puts "TRACE: %s" % line
-          end
-          if stdout.string.size > 0
-            puts "STDOUT:"
-            puts stdout.string
-          end
-          if stderr.string.size > 0
-            puts "STDERR:"
-            puts stderr.string[0..100]
-          end
-        else
-          puts "[SUCCESS]"
-        end
-      end
-    end
-
-    # This module helps tests of command execution.
-    module Command
-      class << self
-        # Run the action with expectation command execution succeeds.
-        def succeed(*options, &b)
-          res = execute(options, &b)
-          res.should.success
-          return res
-        end
-
-        # Run the action with expectation command execution fails.
-        def fail(*options, &b)
-          res = execute(options, &b)
-          res.should.not.success
-          return res
-        end
-
-        private
-
-        # Run the command execution action.
-        def execute(*options, &b)
-          # initialize exit status
-          Global.exit_status = true
-
-          # make result
-          res = CommandResult.new(stdout: StringIO.new("", "w"), stderr: StringIO.new("", "w"))
-
-          # setup stdout and stderr
-          $stdout = res.stdout unless options.include?(:show) or options.include?(:show_stdout)
-          $stderr = res.stderr unless options.include?(:show) or options.include?(:show_stderr)
-
-          # run the action
-          begin
-            b.call
-          rescue Object => e
-            unless options.include?(:show_exception)
-              res.exception = e
-            else
-              raise
-            end
-          end
-
-          # revert stdout and stderr
-          $stdout = STDOUT
-          $stderr = STDERR
-
-          if options.include?(:report)
-            res.report
-          end
-
-          return res
-        end
-      end
-    end
-
     class PioneClientRunner < StructX
       member :title
       member :template, default: "%s"
@@ -103,31 +14,28 @@ module Pione
           runner.default_arguments = ["-o", runner.base.path.to_s]
           b.call(runner)
         end
-
-        # with stand alone mode
-        new(context: context, template: "%s with stand alone mode").tap do |runner|
-          runner.default_arguments = ["-o", runner.base.path.to_s, "--stand-alone"]
-          b.call(runner)
-        end
       end
 
       def run(&b)
         _args = args
         _base = base
         context.it(template % title) do
-          TestHelper::Command.succeed do
-            Pione::Command::PioneClient.run(_args)
-          end
+          Rootage::ScenarioTest.succeed(Pione::Command::PioneClient, _args)
           b.call(_base)
         end
       end
 
+      def fail
+        _args = args
+        context.it(template % title) do
+          Rootage::ScenarioTest.fail(Pione::Command::PioneClient, _args)
+        end
+      end
+
       def timeout(sec)
         _args = args + ["--timeout", sec.to_s]
         context.it(template % title) do
-          TestHelper::Command.fail do
-            Pione::Command::PioneClient.run(_args)
-          end
+          Rootage::ScenarioTest.fail(Pione::Command::PioneClient, _args)
         end
       end
     end

data/lib/pione/tuple-space/basic-tuple.rb

@@ -284,7 +284,7 @@ module Pione
       #   tuple object
       def from_array(ary)
         raise TupleFormatError.new(ary) unless ary.size > 0
-        raise TupleFormatError.new(ary) unless ary.kind_of?(Enumerable)
+        raise TupleFormatError.new(ary) unless ary.respond_to?(:to_a)
         _ary = ary.to_a
         identifier = _ary.first
         raise TupleFormatError.new(identifier) unless TUPLE.has_key?(identifier)

data/lib/pione/tuple-space/tuple-definition.yml

@@ -68,12 +68,10 @@ ExceptionTuple:
 # FinishedTuple represents task finished notifier.
 FinishedTuple:
   - finished
-  - domain:  # task domain
-      String
-  - status:  # status of the task processing
-      Symbol
-  - outputs: # outputs
-      Array
+  - domain : String # task domain
+  - uuid   : String # UUID
+  - status : Symbol # status of the task processing
+  - outputs: Array  # outputs
 
 # ForegroundTuple represents the task is active (rule engine is processing it now).
 ForegroundTuple:

data/lib/pione/tuple-space/tuple-space-interface.rb

@@ -11,9 +11,12 @@ module Pione
 
       # define tuple space operations
       tuple_space_operation :read
+      tuple_space_operation :read!
       tuple_space_operation :read_all
       tuple_space_operation :take
+      tuple_space_operation :take!
       tuple_space_operation :take_all
+      tuple_space_operation :take_all!
       tuple_space_operation :write
       tuple_space_operation :count_tuple
       tuple_space_operation :notify
@@ -23,51 +26,6 @@ module Pione
         @__tuple_space__
       end
 
-      # Read a tuple with no waiting time. If there are no matched tuples, return
-      # +nil+.
-      #
-      # @param tuple [BasicTuple]
-      #   template tuple for query
-      # @return [BasicTuple, nil]
-      #   query result
-      def read!(tuple)
-        begin
-          read(tuple, 0)
-        rescue Rinda::RequestExpiredError
-          nil
-        end
-      end
-
-      # Take a tuple with no waiting time. If there are no matched tuples, return
-      # +nil+.
-      #
-      # @param tuple [BasicTuple]
-      #   template tuple for query
-      # @return [BasicTuple, nil]
-      #   query result
-      def take!(tuple)
-        begin
-          take(tuple, 0)
-        rescue Rinda::RequestExpiredError
-          nil
-        end
-      end
-
-      # Take all tuples with no waiting time. If there are no matched tuples, return
-      # empty array.
-      #
-      # @param tuple [BasicTuple]
-      #   template tuple for query
-      # @return [Array<BasicTuple>]
-      #   query result
-      def take_all!(tuple)
-        begin
-          take_all(tuple, 0)
-        rescue Rinda::RequestExpiredError
-          []
-        end
-      end
-
       # Put a log tuple with the data as a process record into tuple space. The
       # record's value of transition is "complete" by default and the timestamp
       # set automatically.

data/lib/pione/tuple-space/tuple-space-server.rb

@@ -146,6 +146,51 @@ module Pione
         @terminated = true
       end
 
+      # Read a tuple with no waiting time. If there are no matched tuples, return
+      # `nil`.
+      #
+      # @param tuple [BasicTuple]
+      #   template tuple for query
+      # @return [BasicTuple, nil]
+      #   query result
+      def read!(tuple)
+        begin
+          read(tuple, 0)
+        rescue Rinda::RequestExpiredError
+          nil
+        end
+      end
+
+      # Take a tuple with no waiting time. If there are no matched tuples, return
+      # `nil`.
+      #
+      # @param tuple [BasicTuple]
+      #   template tuple for query
+      # @return [BasicTuple, nil]
+      #   query result
+      def take!(tuple)
+        begin
+          take(tuple, 0)
+        rescue Rinda::RequestExpiredError
+          nil
+        end
+      end
+
+      # Take all tuples with no waiting time. If there are no matched tuples, return
+      # empty array.
+      #
+      # @param tuple [BasicTuple]
+      #   template tuple for query
+      # @return [Array<BasicTuple>]
+      #   query result
+      def take_all!(tuple)
+        begin
+          take_all(tuple, 0)
+        rescue Rinda::RequestExpiredError
+          []
+        end
+      end
+
       def inspect
         "#<Pione::TupleSpace::TupleSpaceServer:%s>" % object_id
       end

data/lib/pione/util.rb

@@ -23,6 +23,5 @@ require 'pione/util/positionable'            # source position handler
 require 'pione/util/embeded-expr-expander'   # expand text embeded PIONE expression
 require 'pione/util/free-thread-generator'   # generate threads free from thread group
 require 'pione/util/parslet-extension'       # parslet extension
-require 'pione/util/pnml-compiler'           # toy compiler from PNML to PIONE
 require 'pione/util/last-time'               # get last time of locations
-
+require 'pione/util/boolean-value'           # object -> boolean

data/lib/pione/util/boolean-value.rb

@@ -0,0 +1,62 @@
+module Pione
+  module Util
+    module BooleanValue
+      class << self
+        # Return boolean value of the object.
+        #
+        # @param val [Object]
+        #   target object
+        # @return [Boolean]
+        #   boolean of the object
+        def of(val)
+          case val
+          when NilClass
+            false
+          when TrueClass
+            true
+          when FalseClass
+            false
+          when String
+            of_string(val)
+          when Numeric
+            of_number(val)
+          else
+            raise ArgumentError.new(val)
+          end
+        end
+
+        private
+
+        # Return boolean value of the string. Ignoring letter cases, "true",
+        # "t", "yes", and "y" are true, and "false", "f", "no", and "n" are
+        # false. Ohterwise raise `ArgumentError`.
+        #
+        # @param val [String]
+        #   the string
+        # @return [Boolean]
+        #   boolean of the string
+        def of_string(val)
+          case val.downcase
+          when "true", "t", "yes", "y"
+            true
+          when "false", "f", "no", "n"
+            false
+          else
+            raise ArgumentError.new(val)
+          end
+        end
+
+        # Return boolean value of the number. Return true if the number is
+        # greater than 0.
+        #
+        # @param val [Numeric]
+        #   the number
+        # @return [Boolean]
+        #   boolean of the number
+        def of_number(val)
+          val > 0
+        end
+      end
+    end
+  end
+end