pione 0.2.2 → 0.3.0

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

@@ -1,155 +0,0 @@
-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
-    def find_by_expr(expr)
-      name = expr
-      name = expr.first if expr.kind_of?(DataExprSequence)
-      name = DataExpr.new(expr) if expr.kind_of?(String)
-      query = Tuple[:data].new(name: name, domain: @domain)
-      return tuple_space_server.read_all(query).map do |tuple|
-        tuple.update_criteria = expr.update_criteria if expr.kind_of?(DataExprSequence)
-        tuple
-      end
-    end
-
-    # Find input tuple combinatioins recursively.
-    #
-    # @param type [Symbol]
-    #   input or output
-    # @param exprs [Array<DataExpr>]
-    #   data expressions
-    # @param index
-    #   index
-    # @param vtable [VariableTable]
-    #   variable table
-    # @return [Array<DataFinderResult>]
-    #   the result
-    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)
-
-      # the case for accepting noexistance data
-      if tuples.empty? and head.accept_nonexistence?
-        return find_rec_sub(type, tail, index, tuples, vtable)
-      end
-
-      # make combination results
-      prefix = (type == :input ? "I" : "O")
-      if head.all?
-        # case all distribution
-        new_vtable =
-          make_auto_variables_by_all(type, prefix, head, tuples, vtable, index)
-        unless tuples.empty?
-          return find_rec_sub(type, tail, index, tuples, new_vtable)
-        end
-      else
-        # case each distribution
-        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(type, prefix, expr, tuples, vtable, index)
-      # create new table
-      new_vtable = VariableTable.new(vtable)
-      # set auto variables
-      new_vtable.make_io_auto_variables_by_all(type, prefix, expr, tuples, index)
-
-      return new_vtable
-    end
-
-    # Make auto-variables by the name with 'each' distribution.
-    # @api private
-    def make_auto_variables_by_each(prefix, expr, tuple, vtable, index)
-      # create new table
-      new_vtable = VariableTable.new(vtable)
-      # set auto variables
-      new_vtable.make_io_auto_variables_by_each(prefix, expr, tuple, index)
-
-      return new_vtable
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-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(child_process_infos=[])
-        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?
-          child_process_infos << Util::ProcessInfo.new(pid, thread)
-          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(child_process_infos=[])
-        @monitor.synchronize do
-          # get provider reference
-          begin
-            front = DRbObject.new_with_uri(notifier_uri)
-            front.uuid
-            front
-          rescue
-            # create new provider
-            self.spawn(child_process_infos)
-          end.presence_notifier
-        end
-      end
-    end
-  end
-end

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

@@ -1,85 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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
-        @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: %s" % e
-        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
-              if Pione.debug_mode?
-                puts "[[[dead server]]]"
-                ErrorReport.print(e)
-              end
-              false
-            end
-          end
-        end
-
-        sleep 1
-      rescue Exception
-        # ignore
-      end
-    end
-  end
-end