pione 0.1.0

data/lib/pione/transformer/rule-definition-transformer.rb

@@ -0,0 +1,62 @@
+module Pione
+  module Transformer
+    module RuleDefinitionTransformer
+      include TransformerModule
+
+      def check_model_type(obj, pione_model_type)
+        pione_model_type.match(obj.pione_mode_type)
+      end
+      module_function :check_model_type
+
+      # rule_definition
+      rule(:rule_definition => {
+          :rule_header => simple(:rule_expr),
+          :rule_conditions => sequence(:conditions),
+          :block => simple(:block) }) {
+        inputs = conditions.select{|c| c.type == :input}.map{|c| c.obj}
+        outputs = conditions.select{|c| c.type == :output}.map{|c| c.obj}
+        params = Parameters.merge(
+          *conditions.select{|c| c.type == :param}.map{|c| c.obj}
+        )
+        features = Feature::AndExpr.new(
+          *conditions.select{|c| c.type == :feature}.map{|c| c.obj}
+        )
+        condition = RuleCondition.new(inputs, outputs, params, features)
+        case block
+        when ActionBlock
+          ActionRule
+        when FlowBlock
+          FlowRule
+        end.new(rule_expr, condition, block)
+      }
+
+      ConditionLine = Struct.new(:type, :obj)
+
+      # input_line
+      rule(:input_line => simple(:data_expr)) {
+        TypeDataExpr.check(data_expr)
+        ConditionLine.new(:input, data_expr)
+      }
+
+      # output_line
+      rule(:output_line => simple(:data_expr)) {
+        TypeDataExpr.check(data_expr)
+        ConditionLine.new(:output, data_expr)
+      }
+
+      # param_line
+      rule(:param_line => simple(:param)) {
+        unless TypeAssignment.match(param) or TypeParameters.match(param)
+          raise PioneModelTypeError.new(param, TypeAssignment)
+        end
+        ConditionLine.new(:param, param)
+      }
+
+      # feature_line
+      rule(:feature_line => simple(:feature)) {
+        TypeFeature.check(feature)
+        ConditionLine.new(:feature, feature)
+      }
+    end
+  end
+end

data/lib/pione/transformer/transformer-module.rb

@@ -0,0 +1,37 @@
+module Pione
+  module Transformer
+    module TransformerModule
+      class << self
+        def included(mod)
+          singleton = class << mod; self; end
+          create_pair_by(Parslet, Parslet::Transform).each do |name, orig|
+            singleton.__send__(:define_method, name) do |*args, &b|
+              orig.__send__(name, *args, &b)
+            end
+          end
+
+          class << mod
+            def included(klass)
+              name = :@__transform_rules
+              klass_rules = klass.instance_variable_get(name)
+              klass_rules = klass_rules ? klass_rules + rules : rules
+              klass.instance_variable_set(name, klass_rules)
+            end
+          end
+        end
+
+        private
+
+        def create_pair_by(*mods)
+          mods.inject([]) do |list, mod|
+            list += create_pair(mod)
+          end
+        end
+
+        def create_pair(mod)
+          (mod.methods.sort - Object.methods.sort).map{|m| [m, mod]}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+module Pione
+  # DataFinder finds data tuples from tuple space server.
+  class DataFinder < PioneObject
+
+    # DataFinderResult represents an element of DataFinder#find results. The
+    # attribute +combination+ is a rule inputs combination and +variable_table+
+    # is a variable table including variables for found date set.
+    class DataFinderResult < Struct.new(:combination, :variable_table)
+      # Returns true if the combination is empty.
+      # @return [Boolean]
+      #   true if the result is empty
+      def empty?
+        self[:combination].empty?
+      end
+    end
+
+    include TupleSpaceServerInterface
+
+    # Creates a new finder.
+    # @param [TupleSpaceServer] ts_server
+    #   tuple space server
+    # @param [String] domain
+    #   target data domain to find
+    def initialize(ts_server, domain)
+      set_tuple_space_server(ts_server)
+      @domain = domain
+    end
+
+    # Find tuple combinations by data expressions from tuple space server.
+    # @param [Symbol] type
+    #   :input if target date is for input or :output
+    # @param [DataExpr] exprs
+    #   data-expr list
+    # @param [VariableTable] vtable
+    #   variabel table
+    # @return [DataFinderResult]
+    #   result data set
+    def find(type, exprs, vtable)
+      raise ArgumentError.new(vtable) unless vtable.kind_of?(VariableTable)
+
+      # variable table
+      new_vtable = VariableTable.new(vtable)
+      case type
+      when :input
+        # alias for I
+        new_vtable.set(Variable.new("INPUT"), Variable.new("I"))
+      when :output
+        # alias for O
+        new_vtable.set(Variable.new("OUTPUT"), Variable.new("O"))
+      end
+
+      find_rec(type, exprs, 1, new_vtable)
+    end
+
+    private
+
+    # Finds all data tuples by the expression from a tuple space server.
+    # @param [DataExpr] expr
+    #   query expression of data
+    # @return [DataFinderResult]
+    #   query result
+    # @api private
+    def find_by_expr(expr)
+      expr = DataExpr.new(expr) if expr.kind_of?(String)
+      query = Tuple[:data].new(name: expr, domain: @domain)
+      return tuple_space_server.read_all(query)
+    end
+
+    # Find input tuple combinatioins recursively.
+    def find_rec(type, exprs, index, vtable)
+      # return empty when we reach the recuirsion end
+      return [DataFinderResult.new([], vtable)] if exprs.empty?
+
+      # expand variables and compile to regular expression
+      head = exprs.first.eval(vtable)
+      tail = exprs.drop(1)
+
+      # find an input data by name from tuple space server
+      tuples = find_by_expr(head)
+
+      # make combination results
+      prefix = (type == :input ? "I" : "O")
+      if head.all?
+        # case all modifier
+        new_vtable =
+          make_auto_variables_by_all(prefix, head, tuples, vtable)
+        unless tuples.empty?
+          return find_rec_sub(type, tail, index, tuples, new_vtable)
+        end
+      else
+        # case each modifier
+        return tuples.map {|tuple|
+          args = [prefix, head, tuple, vtable, index]
+          new_vtable = make_auto_variables_by_each(*args)
+          find_rec_sub(type, tail, index, tuple, new_vtable)
+        }.flatten
+      end
+
+      # available combinations were not found
+      return []
+    end
+
+    # @api private
+    def find_rec_sub(type, tail, index, data, vtable)
+      find_rec(type, tail, index+1, vtable).map do |res|
+        new_combination = res.combination.unshift(data)
+        new_vtable = res.variable_table
+        DataFinderResult.new(new_combination, new_vtable)
+      end
+    end
+
+    # Make auto-variables by the name modified 'all'.
+    # @api private
+    def make_auto_variables_by_all(prefix, expr, tuples, vtable)
+      # create new table
+      new_vtable = VariableTable.new(vtable)
+      # variable
+      var = Variable.new(prefix)
+
+      # setup rule-io list
+      list = new_vtable.get(var)
+      list = RuleIOList.new unless list
+      io_list = RuleIOList.new
+      new_vtable.set!(var, list.add(io_list))
+
+      # convert each tuples
+      tuples.each do |tuple, i|
+        elt = RuleIOElement.new(PioneString.new(tuple.name))
+        elt.uri = PioneString.new(tuple.uri)
+        elt.match = PioneList.new(
+          *expr.match(tuple.name).to_a.map{|m| PioneString.new(m)}
+        )
+        io_list.add!(elt)
+      end
+
+      return new_vtable
+    end
+
+    # Make auto-variables by the name modified 'each'.
+    # @api private
+    def make_auto_variables_by_each(prefix, expr, tuple, vtable, index)
+      # create new table
+      new_vtable = VariableTable.new(vtable)
+      # variable
+      var = Variable.new(prefix)
+      # matched data
+      md = expr.match(tuple.name).to_a
+
+      # setup rule-io list
+      list = new_vtable.get(var)
+      list = RuleIOList.new unless list
+      elt = RuleIOElement.new(PioneString.new(tuple.name))
+      elt.uri = PioneString.new(tuple.uri)
+      elt.match = PioneList.new(*md.map{|d| PioneString.new(d)})
+      new_vtable.set!(var, list.add(elt))
+
+      # set special variable if index equals 1
+      if prefix == 'I' && index == 1
+        new_vtable.set(Variable.new("*"), PioneString.new(md[1]))
+      end
+
+      return new_vtable
+    end
+  end
+end

data/lib/pione/tuple-space/presence-notifier.rb

@@ -0,0 +1,83 @@
+module Pione
+  module TupleSpace
+    class PresenceNotifier < PioneObject
+      def self.inherited(subclass)
+        subclass.instance_variable_set(:@monitor, Monitor.new)
+      end
+
+      def self.command_name
+        @command_name
+      end
+
+      def self.set_command_name(name)
+        @command_name = name
+      end
+
+      def self.notifier_uri
+        @notifier_uri.call
+      end
+
+      def self.set_notifier_uri(proc)
+        @notifier_uri = proc
+      end
+
+      # Creates the tuple space provider as new process.
+      # @return [BasicFront]
+      #   tuple space provider or receiver front
+      def self.spawn
+        user_message "create process for %s" % command_name
+        # create provider process
+        args = [command_name, '--parent-front', Global.front.uri]
+        args << "--debug" if Pione.debug_mode?
+        args << "--show-communication" if Global.show_communication
+        args << "--show-presence-notifier" if Global.show_presence_notifier
+        if self == TupleSpaceReceiver
+          args << "--presence-port"
+          args << Global.presence_port.to_s
+        end
+        args << "--my-ip-address"
+        args << Global.my_ip_address
+        if self == TupleSpaceProvider
+          Global.presence_notification_addresses.each do |address|
+            args << "--presence-notification-address"
+            args << address.to_s
+          end
+        end
+        pid = Process.spawn(*args)
+        thread = Process.detach(pid)
+        # wait that the provider starts up
+        while thread.alive?
+          begin
+            front = DRbObject.new_with_uri(notifier_uri)
+            break if front.uuid
+          rescue
+            sleep 0.1
+          end
+        end
+        if thread.alive?
+          return front
+        else
+          # failed to run pione-tuple-space-provider
+          Process.abort("You cannot run %s." % command_name)
+        end
+      end
+
+      # Returns the provider instance.
+      # @return [PresenceNotifier]
+      #   tuple space provider or receiver instance as druby object
+      def self.instance
+        @monitor.synchronize do
+          # get provider reference
+          begin
+            front = DRbObject.new_with_uri(notifier_uri)
+            front.uuid
+            front
+          rescue
+            # create new provider
+            self.spawn
+          end.presence_notifier
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Pione
+  module TupleSpace
+    class Relay < PioneObject
+      def initialize
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Pione
+  module TupleSpace
+    # TupleSpaceProvider provides tuple space server's location to tuple space
+    # receivers.
+    class TupleSpaceProvider < PresenceNotifier
+      include DRbUndumped
+
+      set_command_name "pione-tuple-space-provider"
+      set_notifier_uri Proc.new {Global.tuple_space_provider_uri}
+
+      attr_accessor :tuple_space_servers
+
+      # Creatas a new server. This method assumes to be called from
+      # pione-tuple-space-provider command only. So you should not initialize
+      # server directly.
+      def initialize
+        super
+
+        # set variables
+        @tuple_space_servers = []
+        @terminated = false
+
+        # start agents
+        @keeper = Agent::TrivialRoutineWorker.new(
+          Proc.new do
+            send_packet
+            sleep 5
+          end
+        )
+      end
+
+      def start
+        @keeper.start
+      end
+
+      def add_tuple_space_server(tuple_space_server)
+        @tuple_space_servers << tuple_space_server
+      end
+
+      # Sends empty tuple space server list.
+      def terminate
+        return unless @terminated
+        @terminated = true
+        @keeper_agent.terminate
+      end
+
+      def terminated?
+        @terminated
+      end
+
+      alias :finalize :terminate
+
+      private
+
+      # Sends presence notification to tuple space receivers as UDP packet.
+      # @return [void]
+      def send_packet
+        # setup reference data
+        port = /druby:\/\/(.*):(\d+)/.match(Global.front.uri)[2].to_i
+        @ref ||= Marshal.dump(port)
+        # open a socket
+        socket = UDPSocket.open
+        # address to send broadcast
+        addresses = Global.presence_notification_addresses
+        begin
+          if Global.show_presence_notifier
+            args = [Global.front.uri, addresses.join(", "), Time.now]
+            puts "sent presence notifier from %s to %s at %s" % args
+          end
+          # send packet
+          socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+          addresses.each {|addr| socket.send(@ref, 0, addr.host, addr.port)}
+        rescue => e
+          if Global.show_presence_notifier
+            puts "tuple-space-provider: something is bad..."
+            Util::ErrorReport.print(e)
+          end
+        ensure
+          # close the socket always
+          socket.close
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module Pione
+  module TupleSpace
+    class TupleSpaceReceiver < PresenceNotifier
+      class InstanceError < StandardError; end
+
+      set_command_name "pione-tuple-space-receiver"
+      set_notifier_uri Proc.new {Global.tuple_space_receiver_uri}
+
+      def self.start(broker)
+        instance.register(broker)
+      end
+
+      attr_accessor :drb_service
+
+      def initialize
+        @brokers = []
+        @tuple_space_servers = {}
+        @socket = open_socket
+
+        # lock
+        @tuple_space_server_lock = Mutex.new
+        @broker_lock = Mutex.new
+
+        # subagents
+        @tuple_space_server_receiver =
+          Agent::TrivialRoutineWorker.new(Proc.new{receive_tuple_space_servers})
+        @updater = Agent::TrivialRoutineWorker.new(Proc.new{update_tuple_space_servers})
+      end
+
+      # Registers the agent.
+      def register(agent)
+        @broker_lock.synchronize { @brokers << agent }
+      end
+
+      # Start to receive tuple space servers.
+      def start
+        @tuple_space_server_receiver.start
+        @updater.start
+      end
+
+      def tuple_space_servers
+        @tuple_space_server_lock.synchronize do
+          @tuple_space_servers.keys
+        end
+      end
+
+      # Send empty tuple space server list.
+      def finalize
+        puts "finalize"
+        @terminated = true
+        @tuple_space_server_receiver.terminate
+        @socket.close
+        @updater.terminate
+        @tuple_space_servers = []
+      end
+
+      alias :terminate :finalize
+
+      def terminated?
+        @terminated
+      end
+
+      private
+
+      # Opens receiver socket.
+      # @return [UDPSocket]
+      #   server socket
+      def open_socket
+        socket = UDPSocket.open
+        socket.bind(Socket::INADDR_ANY, Global.presence_port)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+        return socket
+      end
+
+      # Receives tuple space servers and updates the table.
+      # @return [void]
+      def receive_tuple_space_servers
+        data, addr = @socket.recvfrom(1024)
+        port = Marshal.load(data)
+        ip_address = addr[3]
+        provider_front = DRbObject.new_with_uri("druby://%s:%s" % [ip_address, port])
+        # need return of ping in short time
+        Timeout.timeout(1) do
+          provider_front.ping
+          provider_front.tuple_space_servers.each do |tuple_space_server|
+            @tuple_space_server_lock.synchronize do
+              @tuple_space_servers[tuple_space_server] = Time.now
+            end
+          end
+        end
+        if Global.show_presence_notifier
+          puts "presence notifier was received: %s" % provider_front.__drburi
+        end
+      rescue DRb::DRbConnError, DRb::ReplyReaderThreadError, IOError => e
+        @socket.close
+        @socket = open_socket
+        if Global.show_presence_notifier
+          puts "tuple space receiver disconnected"
+        end
+      rescue Exception
+        # ignore
+      end
+
+      def update_tuple_space_servers
+        # update tuple space server list
+        @tuple_space_server_lock.synchronize do
+          @tuple_space_servers.delete_if do |server, time|
+            begin
+              # ping
+              timeout(1) { server.ping }
+              # check timespan
+              (Time.now - time) > Global.tuple_space_receiver_disconnect_time
+            rescue Exception
+              true
+            end
+          end
+        end
+
+        # update broker
+        @broker_lock.synchronize do
+          @brokers.select! do |broker|
+            begin
+              timeout(1) { broker.ping }
+              broker.update_tuple_space_servers(tuple_space_servers)
+              true
+            rescue Exception => e
+              puts "[[[dead server]]]"
+              ErrorReport.print(e)
+              false
+            end
+          end
+        end
+
+        sleep 1
+      rescue Exception
+        # ignore
+      end
+    end
+  end
+end