pione 0.1.0

data/lib/pione/command/pione-tuple-space-viewer.rb

@@ -0,0 +1,151 @@
+module Pione
+  module Command
+    class PioneTupleSpaceViewer < BasicCommand
+      set_program_name("pione-tuple-space-viewer")
+
+      define_option('-i', '--identifier=NAME', 'show tuples that have the identifier') do |name|
+        @identifiers << name
+      end
+
+      define_option('-e', '--exclude=NAME', 'exclude the tuple identifier') do |name|
+        @exclusions << name
+      end
+
+      define_option('--package=NAME', 'show tuples which domain has the package name') do |name|
+        @package = name
+      end
+
+      define_option('--rule=NAME', 'show tuples which domain has the rule name') do |name|
+        @rule = name
+      end
+
+      define_option('--rule-path=NAME', 'show tuples which domain has the rule path') do |path|
+        @rule_path = path
+      end
+
+      define_option('--data-name=NAME', 'show tuples that has the the name') do |name|
+        @data_name = name
+      end
+
+      define_option(
+        '--type=TYPE',
+        'show the bag which has the type("bag", "read_waiter", or "take_waiter")'
+      ) do |bag_type|
+        @bag_type = bag_type.to_sym
+      end
+
+      define_option('--client=ADDRESS', 'druby address of target client process') do |address|
+        @address = address
+      end
+
+      def initialize
+        @identifiers = []
+        @exclusions = []
+        @package = nil
+        @rule = nil
+        @rule_path = nil
+        @data_name = nil
+        @bag_type = nil
+        @tuple_space_servers = []
+      end
+
+      def prepare
+        require 'pp'
+        find_tuple_space_servers
+
+        # tuple space servers are not found
+        if @tuple_space_servers.empty?
+          abort("No tuple space servers.")
+        end
+      end
+
+      def start
+        # print each bags
+        @tuple_space_servers.each do |address, tuple_space_server|
+          puts "TupleSpaceServer: %s" % Terminal.red(address)
+          puts "-"*78
+          if @bag_type == :bag or @bag_type.nil?
+            puts "*** bag ***"
+            show_bag(tuple_space_server, :bag)
+          end
+          if @bag_type == :read_waiter or @bag_type.nil?
+            puts "*** read waiter ***"
+            show_bag(tuple_space_server, :read_waiter)
+          end
+          if @bag_type == :take_waiter or @bag_type.nil?
+            puts "*** take waiter ***"
+            show_bag(tuple_space_server, :take_waiter)
+          end
+
+          # summary
+          puts "*** summary ***"
+          puts "task: %s" % tuple_space_server.task_size
+          puts "working: %s" % tuple_space_server.working_size
+          puts "finished: %s" % tuple_space_server.finished_size
+          puts "data: %s" % tuple_space_server.data_size
+        end
+      end
+
+      private
+
+      def find_tuple_space_servers
+        if @address
+          @tuple_space_servers << [@address, get_tuple_space_server(@address)]
+        else
+          find_tuple_space_servers_in_range
+        end
+      end
+
+      def find_tuple_space_servers_in_range
+        Global.client_front_port_range.each do |port|
+          begin
+            address = "druby://%s:%s" % [Global.my_ip_address, port]
+            @tuple_space_servers << [address, get_tuple_space_server(address)]
+          rescue
+            # ignore
+          end
+        end
+      end
+
+      # Gets a tuple space server from the address.
+      def get_tuple_space_server(address)
+        ref = DRbObject.new_with_uri(address)
+        ref.ping
+        ref.tuple_space_server
+      end
+
+      def show_bag(tuple_space_server, type)
+        tuple_space_server.all_tuples(type).each do |tuple|
+          next if not(@identifiers.empty?) and not(@identifiers.include?(tuple.first.to_s))
+          next if @exclusions.include?(tuple.first.to_s)
+
+          t = Tuple.from_array(tuple)
+
+          # rule_path
+          if @rule_path
+            if t.respond_to?(:domain)
+              next unless /^(#{@rule_path})/.match(t.domain)
+            else
+              next
+            end
+          end
+
+          # name
+          if @data_name
+            if t.kind_of?(Tuple::Data) and t.respond_to?(:name)
+              next unless Model::DataExpr.new(@data_name).match(t.name)
+            else
+              next
+            end
+          end
+
+          # show
+          res = PP.pp(tuple, "")
+          res.gsub!(/\:[a-z]\w+/) {|s| Terminal.red(s) }
+          res.gsub!(/\#<(\S+)/) {|s| "#<%s" % Terminal.green($1) }
+          puts res
+        end
+      end
+    end
+  end
+end

data/lib/pione/command/tuple-space-provider-owner.rb

@@ -0,0 +1,6 @@
+module Pione
+  module Command
+    module TupleSpaceProviderOwner
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Pione
+  module Front
+    # FrontError is raised when front server cannnot start.
+    class FrontError < StandardError; end
+
+    # This is base class for all PIONE front classes. PIONE fronts exist in each
+    # command and control its process.
+    class BasicFront < PioneObject
+      include DRbUndumped
+      extend Forwardable
+
+      attr_reader :command
+      attr_reader :uri
+      attr_reader :attrs
+      attr_reader :link
+
+      # Creates a front server as druby's service.
+      def initialize(command, port)
+        @command = command
+        # @uri = start_service(port, {:verbose => true})
+        @uri = start_service(port, {})
+        @attrs = {}
+      end
+
+      # Returns the pid.
+      def pid
+        Process.pid
+      end
+
+      def link
+        @__link__
+      end
+
+      # Terminates the front.
+      def terminate
+        DRb.stop_service
+      end
+
+      private
+
+      # Starts drb service and returns the URI.
+      def start_service(port, config)
+        if port.kind_of?(Range)
+          port = port.each
+          begin
+            uri = "druby://%s:%s" % [Global.my_ip_address, port.next]
+            @__link__ = DRb.start_service(uri, self, config)
+          rescue StopIteration => e
+            raise FrontError.new("You couldn't start front server.")
+          rescue
+            retry
+          end
+        else
+          begin
+            DRb.start_service(port ? "druby://%s:%s" % [Global.my_ip_address, port] : nil, self, config)
+          rescue => e
+            raise FrontError.new("You couldn't start front server: %s" % e.message)
+          end
+        end
+        return DRb.uri
+      end
+    end
+  end
+end

data/lib/pione/front/broker-front.rb

@@ -0,0 +1,30 @@
+module Pione
+  module Front
+    # BrokerFront is a front class for pione-broker command.
+    class BrokerFront < BasicFront
+      include TaskWorkerOwner
+
+      def_delegator :@command, :broker
+
+      # Create a new front.
+      def initialize(command)
+        super(command, Global.broker_front_port_range)
+        initialize_task_worker_owner
+      end
+
+      def get_tuple_space_server(connection_id)
+        broker.get_tuple_space_server(connection_id)
+      end
+
+      # Override the method with adding task worker agent to broker.
+      def add_task_worker_front(task_worker_front, connection_id)
+        super
+        broker.task_workers << task_worker_front.agent
+      end
+
+      def set_tuple_space_receiver(uri)
+        Global.set_tuple_space_receiver_uri(uri)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Pione
+  module Front
+    # ClientFront is a front class for +pione-client+ command.
+    class ClientFront < BasicFront
+      extend Forwardable
+      include TaskWorkerOwner
+      include TupleSpaceProviderOwner
+
+      def_delegator :@command, :tuple_space_server
+      def_delegator :@command, :name
+
+      # Create a new front.
+      def initialize(command)
+        super(command, Global.client_front_port_range)
+        initialize_task_worker_owner
+      end
+
+      # Returns client's tuple space server for task workers.
+      # @param [String] connection_id
+      #   connection id of task worker
+      # @return [TupleSpaceServer]
+      #   tuple space server
+      def get_tuple_space_server(connection_id)
+        tuple_space_server
+      end
+    end
+  end
+end

data/lib/pione/front/relay-front.rb

@@ -0,0 +1,19 @@
+module Pione
+  module Front
+    class RelayFront < BasicFront
+      include TupleSpaceProviderOwner
+
+      def_delegator :@command, :presence_port
+      def_delegator :@command, :tuple_space_server
+
+      # Create a new front.
+      def initialize(command)
+        super(command, Global.relay_front_port_range)
+      end
+
+      def presence_notifier
+        tuple_space_provider
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Pione
+  module Front
+    # TaskWorkerFront is a front class for pione-task-worker command.
+    class TaskWorkerFront < BasicFront
+      def_delegator :@command, :caller_front
+      def_delegator :@command, :connection_id
+      def_delegator :@command, :agent
+      def_delegator :@command, :tuple_space_server
+
+      # Create a new front.
+      def initialize(command)
+        super(command, Global.task_worker_front_port_range)
+      end
+    end
+  end
+end

data/lib/pione/front/task-worker-owner.rb

@@ -0,0 +1,42 @@
+module Pione
+  module Front
+    module TaskWorkerOwner
+      attr_reader :task_worker_fronts
+      attr_reader :task_worker_front_connection_id
+
+      def get_tuple_space_server
+        raise NotImplementedError
+      end
+
+      def add_task_worker_front(task_worker_front, connection_id)
+        @task_worker_fronts << task_worker_front
+        @task_worker_front_connection_id << connection_id
+      end
+
+      def remove_task_worker_front(task_worker_front, connection_id)
+        @task_worker_fronts.delete(task_worker_front)
+        @task_worker_front_connection_id.delete(connection_id)
+      end
+
+      def terminate
+        terminate_task_worker_fronts
+      end
+
+      private
+
+      def initialize_task_worker_owner
+        @task_worker_fronts = []
+        @task_worker_front_connection_id = []
+      end
+
+      def terminate_task_worker_fronts
+        @task_worker_fronts.each do |front|
+          begin
+            front.terminate
+          rescue
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/front/tuple-space-provider-front.rb

@@ -0,0 +1,22 @@
+module Pione
+  module Front
+    # TupleSpaceProviderFront is a front class for pione-tuple-space-provider
+    # command.
+    class TupleSpaceProviderFront < BasicFront
+      def_delegator :@command, :tuple_space_provider
+      def_delegator :@command, :presence_port
+
+      def initialize(command)
+        super(command, Global.tuple_space_provider_front_port_range)
+      end
+
+      def presence_notifier
+        tuple_space_provider
+      end
+
+      def tuple_space_servers
+        tuple_space_provider.tuple_space_servers
+      end
+    end
+  end
+end

data/lib/pione/front/tuple-space-provider-owner.rb

@@ -0,0 +1,11 @@
+module Pione
+  module Front
+    module TupleSpaceProviderOwner
+      # Sets the uri as tuple space provider.
+      # @return [void]
+      def set_tuple_space_provider(uri)
+        Global.tuple_space_provider_uri = uri
+      end
+    end
+  end
+end

data/lib/pione/front/tuple-space-receiver-front.rb

@@ -0,0 +1,18 @@
+module Pione
+  module Front
+    # TupleSpaceProviderFront is a front class for pione-tuple-space-receiver
+    # command.
+    class TupleSpaceReceiverFront < BasicFront
+      def_delegator :@command, :tuple_space_receiver
+      def_delegator :@command, :presence_port
+
+      def initialize(command)
+        super(command, Global.tuple_space_receiver_front_port_range)
+      end
+
+      def presence_notifier
+        tuple_space_receiver
+      end
+    end
+  end
+end

data/lib/pione/model/assignment.rb

@@ -0,0 +1,89 @@
+module Pione::Model
+  # Assignment represents a value assignment for variable.
+  # @example
+  #   # assigning a string
+  #   $X := "a"
+  #   # => Assignment.new(Variable.new('X'), PioneString.new('a'))
+  # @example
+  #   # assigning a variable value
+  #   $X := $Y
+  #   # => Assignment.new(Variable.new('X'), Variable.new('Y'))
+  class Assignment < BasicModel
+    set_pione_model_type TypeAssignment
+
+    # Returns the variable part of assignment.
+    attr_reader :variable
+
+    # Returns the expression part of assignment.
+    attr_reader :expr
+
+    # Creates an assignment.
+    # @param [Variable] variable
+    #   variable part of assignment
+    # @param [BasicModel] expr
+    #   expression part of assignment
+    def initialize(variable, expr)
+      check_argument_type(variable, Variable)
+      check_argument_type(expr, BasicModel)
+      @variable = variable
+      @expr = expr
+      super()
+    end
+
+    # Evaluates the assignment. This method updates the variable table with the
+    # variable and expression. The expression is pushed into the table directory
+    # as it is because of lazy evaluation.
+    # @param [VariableTable] vtable
+    #   variable table for evaluation
+    # @return [BasicModel]
+    #   self
+    def eval(vtable)
+      vtable.set(@variable, @expr)
+    end
+
+    def set_toplevel(b)
+      @variable.set_toplevel(b)
+    end
+
+    # Returns true if the assignment is defined in toplevel.
+    # @return [Boolean]
+    #   true if the assignment is defined in toplevel
+    def toplevel?
+      @variable.toplevel?
+    end
+
+    # Returns false because assignment form is complex(pair of variable and
+    # expression).
+    # @return [Boolean]
+    #   false
+    def atomic?
+      false
+    end
+
+    # Returns true if the expression part of assignment includes variable.
+    # @return [Boolean]
+    #   true if the expression part of assignment includes variable
+    def include_variable?
+      @expr.include_variable?
+    end
+
+    # @api private
+    def textize
+      "%s:=%s" % [@variable.textize, @expr.textize]
+    end
+
+    # Returns true if other is a variable object which name is same as myself.
+    # @api private
+    def ==(other)
+      return false unless other.kind_of?(self.class)
+      @variable == other.variable && @expr == other.expr
+    end
+
+    alias :eql? :"=="
+
+    # @api private
+    def hash
+      @variable.hash + @expr.hash
+    end
+  end
+end