pione 0.3.2 → 0.4.0

data/lib/pione/model.rb

@@ -0,0 +1,7 @@
+module Pione
+  # `Pione::Model` is a namespace for all command models.
+  module Model; end
+end
+
+require 'pione/model/notification-listener-model'
+require 'pione/model/task-worker-broker-model'

data/lib/pione/model/notification-listener-model.rb

@@ -0,0 +1,29 @@
+module Pione
+  module Model
+    # NotificationListenerModel is a model for pione-notification-listener. This
+    # manages recipiants lifecycle.
+    class NotificationListenerModel < Rootage::Model
+      attr_reader :recipients
+
+      def initialize
+        super
+        @recipients = []
+        @lock = Mutex.new
+      end
+
+      # Add the URI of recipient.
+      def add_recipient(uri)
+        @lock.synchronize do
+          unless @recipients.include?(uri)
+            @recipients << uri
+          end
+        end
+      end
+
+      # Delete the recipients.
+      def delete_recipient(*uris)
+        @lock.synchronize {uris.each {|uri| @recipients.delete(uri)}}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+module Pione
+  module Model
+    class TaskWorkerBrokerModel < Rootage::Model
+      attr_accessor :task_workers
+      attr_accessor :tuple_space
+      attr_reader :tuple_space_lock     # lock for tuple space table
+
+      def initialize
+        super
+
+        @spawnings = 0                  # number of current spawning task worker
+        @task_worker_lock = Monitor.new # lock for task worker table
+        @task_workers = Array.new       # known task worker fronts
+        @tuple_space_lock = Monitor.new
+        @tuple_space = Hash.new         # known tuple space table
+
+        self[:spawn_task_worker] = true
+      end
+
+      # Add the tuple space.
+      def add_tuple_space(tuple_space)
+        uuid = tuple_space.uuid
+
+        # update tuple space table with the id
+        @tuple_space_lock.synchronize {@tuple_space[uuid] = tuple_space}
+      end
+
+      # Create a task worker for the tuple space. This method returns true if we
+      # suceeds to spawn the task worker, or returns false.
+      def create_task_worker(tuple_space)
+        res = true
+
+        @task_worker_lock.synchronize do
+          @spawnings += 1
+
+          # spawn a new process of pione-task-worker command
+          if self[:spawn_task_worker]
+            begin
+              spawner = Command::PioneTaskWorker.spawn(self, Global.features, tuple_space.uuid)
+              @task_workers << spawner.child_front
+              spawner.when_terminated {delete_task_worker(spawner.child_front)}
+            rescue Command::SpawnError => e
+              Log::Debug.system("Task worker broker agent failed to spawn a task worker: %e" % e.message)
+              res = false
+            end
+          else
+            @task_workers << Agent::TaskWorker.start(tuple_space, Global.expressional_features, @env)
+          end
+
+          @spawnings -= 1
+        end
+
+        return res
+      end
+
+      def delete_task_worker(worker)
+        @task_worker_lock.synchronize {@task_workers.delete(worker)}
+      end
+
+      # Delete all dead task workers.
+      def delete_dead_task_workers
+        @task_worker_lock.synchronize do
+          @task_workers.delete_if do |worker|
+            not(Util.ignore_exception {timeout(1) {worker.ping}})
+          end
+        end
+      end
+
+      # Delete all dead tuple spaces.
+      def delete_dead_tuple_spaces
+        @tuple_space_lock.synchronize do
+          @tuple_space.delete_if do |_, space|
+            not(Util.ignore_exception {timeout(1) {space.ping}})
+          end
+        end
+      end
+
+      # Return excess number of task workers belong to the broker.
+      def excess_task_workers
+        @task_worker_lock.synchronize do
+          @task_worker_size - @task_workers.size - @spawnings
+        end
+      end
+
+      # Get the tuple space.
+      def get_tuple_space(tuple_space_id)
+        @tuple_space_lock.synchronize {@tuple_space[tuple_space_id]}
+      end
+
+      # Return number of task workers the broker manages.
+      def quantity
+        @task_worker_lock.synchronize {@task_workers.size}
+      end
+
+      # Terminate first task worker that satisfies the condition.
+      def terminate_task_worker_if(&condition)
+        @task_worker_lock.synchronize do
+          @task_workers.each do |worker|
+            if condition.call(worker)
+              worker.terminate
+              @task_workers.delete(worker)
+              return true
+            end
+          end
+        end
+        return false
+      end
+
+      # Return known tuple spaces.
+      def tuple_spaces
+        @tuple_space_lock.synchronize {@tuple_space.values}
+      end
+
+      # Update tuple space list.
+      def update_tuple_spaces(tuple_spaces)
+        @tuple_space_lock.synchronize do
+          # clear and update tuple space list
+          @tuple_space.clear
+          tuple_spaces.each {|tuple_space| add_tuple_space(tuple_space)}
+
+          Log::Debug.system do
+            list = @tuple_space.values.map{|space| space.__drburi}
+            "Task worker broker has updated tuple space table: %s" % [list]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/notification.rb

@@ -0,0 +1,13 @@
+module Pione
+  # `Pione::Notification` is a namespace for notification related classes.
+  module Notification
+  end
+end
+
+require 'pione/notification/exception'
+require 'pione/notification/message'
+require 'pione/notification/address'
+require 'pione/notification/receiver'
+require 'pione/notification/transmitter'
+require 'pione/notification/recipient'
+require 'pione/notification/task-worker-broker-recipient'

data/lib/pione/notification/address.rb

@@ -0,0 +1,104 @@
+module Pione
+  module Notification
+    # Nofitication::Address provides utility methods for notification addresses.
+    module Address
+      MULTICAST_ADDRESS = IPAddr.new("224.0.0.0/4")
+
+      class << self
+        # Convert the target address to URI.
+        def target_address_to_uri(address)
+          address_to_uri(
+            address,
+            Global.default_notification_target_host,
+            Global.default_notification_target_port
+          )
+        end
+
+        # Convert the receiver address to URI.
+        def receiver_address_to_uri(address)
+          address_to_uri(
+            address,
+            Global.default_notification_receiver_host,
+            Global.default_notification_receiver_port
+          )
+        end
+
+        # Return default target address.
+        def default_target_address
+          host_and_port_to_uri(
+            Global.default_notification_target_host,
+            Global.default_notification_target_port
+          )
+        end
+
+        # Return default receiver address.
+        def default_receiver_address
+          host_and_port_to_uri(
+            Global.default_notification_receiver_host,
+            Global.default_notification_receiver_port
+          )
+        end
+
+        private
+
+        # Convert the address to URI.
+        def address_to_uri(address, default_host, default_port)
+          uri = URI.parse(address)
+          unless ["pnb", "pnm", "pnu"].include?(uri.scheme)
+            raise URI::InvalidURIError
+          end
+          uri.host = default_host if uri.host == "."
+          uri.port = default_port if uri.port.nil?
+          return uri
+        rescue URI::InvalidURIError
+          if port_only?(address)
+            return port_to_uri(default_host, address)
+          end
+
+          if host_only?(address)
+            return host_to_uri(default_port, address)
+          end
+
+          host_and_port_to_uri(*address.split(":"))
+        end
+
+        # Return true if the address contains port only.
+        def port_only?(address)
+          address[0] == ":"
+        end
+
+        # Return true if the address conatains host only.
+        def host_only?(address)
+          not(address.include?(":"))
+        end
+
+        # Return true if the host is a multicast address.
+        def multicast?(host)
+          _host = IPSocket.getaddress(host)
+          MULTICAST_ADDRESS.include?(_host)
+        end
+
+        # Convert the host to URI. The scheme assumes "pnb" excluding multicast
+        # addresses.
+        def host_to_uri(default_port, host)
+          scheme = multicast?(host) ? "pnm" : "pnb"
+          URI.parse("%s://%s:%s" % [scheme, host, default_port])
+        end
+
+        # Convert the port to URI. The scheme assumes "pnb" excluding multicast
+        # addresses.
+        def port_to_uri(default_host, address)
+          scheme = multicast?(default_host) ? "pnm" : "pnb"
+          URI.parse("%s://%s:%s" % [scheme, default_host, address.sub(":", "")])
+        end
+
+        # Convert the host and port to URI. The scheme assumes "pnb" excluding
+        # multicast addresses.
+        def host_and_port_to_uri(host, port)
+          scheme = multicast?(host) ? "pnm" : "pnb"
+          URI.parse("%s://%s:%s" % [scheme, host, port])
+        end
+      end
+    end
+  end
+end

data/lib/pione/notification/exception.rb

@@ -0,0 +1,10 @@
+module Pione
+  module Notification
+    # `Notification::Error` is a base exception class related notification
+    # errors.
+    class Error < StandardError; end
+
+    # `Notification::MessageError` is a error for message format.
+    class MessageError < Error; end
+  end
+end

data/lib/pione/notification/message.rb

@@ -0,0 +1,109 @@
+module Pione
+  module Notification
+    class Message
+      PROTOCOL_VERSION = "PN1"
+
+      # Load a notification from the dumped data.
+      #
+      # @param data [String]
+      #   dumped data
+      # @return [Network::Notification]
+      #   notification object
+      def self.load(data)
+        io = StringIO.new(data)
+
+        # read
+        total = io.read(2).unpack("n")[0]
+        psize = io.read(1).unpack("C")[0]
+        version = io.read(psize)
+        nsize = io.read(1).unpack("C")[0]
+        notifier = io.read(nsize)
+        tsize = io.read(1).unpack("C")[0]
+        type = io.read(tsize)
+        msize = io.read(2).unpack("n")[0]
+        json = io.read(msize)
+
+        # check size
+        unless total == psize + nsize + tsize + msize
+          raise MessageError.new("Total size and real message size are different.")
+        end
+
+        # convert json to ruby object
+        begin
+          content = JSON.parse(json)
+        rescue JSON::ParserError
+          MessageError.new("Format of the message content is invalid.")
+        end
+
+        new(notifier, type, content)
+      end
+
+      attr_reader :notifier
+      attr_reader :type
+      attr_reader :version
+
+      # @param notifier [String]
+      #   name of notification sender
+      # @param type [String]
+      #   notification type name
+      # @param message [Hash]
+      #   JSON data
+      # @param version [String]
+      #   protocol version
+      def initialize(notifier, type, content, version=PROTOCOL_VERSION)
+        @notifier = notifier
+        @type = type
+        @content = content
+        @version = version
+      end
+
+      # Return the value.
+      #
+      # @param name [String]
+      #   key of message content
+      # @return [Object]
+      #   the value
+      def [](name)
+        @content[name]
+      end
+
+      # Dump the notification message to a serialized string.
+      #
+      # @return [String]
+      #   a serialized string
+      def dump
+        json = JSON.generate(@content)
+
+        psize = PROTOCOL_VERSION.bytesize
+        nsize = @notifier.bytesize
+        tsize = @type.bytesize
+        msize = json.bytesize
+        total = psize + nsize + tsize + msize
+
+        if nsize > 255
+          raise MessageError.new('notifier "%s" is too long.' % @notifier)
+        end
+
+        if tsize > 255
+          raise MessageError.new('type "%s" is too long.' % @type)
+        end
+
+        if msize > 65335
+          raise MessageError.new('message is too long.')
+        end
+
+        if total > 65535
+          raise MessageError.new('The notification is too long.')
+        end
+
+        # build a serialized string
+        data = ""
+        data << [total].pack("n")
+        data << [psize].pack("C") << PROTOCOL_VERSION
+        data << [nsize].pack("C") << @notifier
+        data << [tsize].pack("C") << @type
+        data << [msize].pack("n") << json
+      end
+    end
+  end
+end

data/lib/pione/notification/receiver.rb

@@ -0,0 +1,90 @@
+module Pione
+  module Notification
+    # `Notification::Receiver` provides the function to receive notification
+    # packets. Be careful we assume notification's packet is small.
+    class Receiver
+      # a lock for receiving notifications
+      LOCK = Mutex.new
+
+      MAX_SIZE = 65535
+
+      # @param uri [URI]
+      #   URI of receiver address
+      def initialize(uri)
+        unless ["pnb", "pnm", "pnu"].include?(uri.scheme)
+          raise ArgumentError.new(uri)
+        end
+
+        @uri = uri
+        open
+      end
+
+      # Receive a notification packet.
+      def receive
+        data, addr = LOCK.synchronize {@socket.recvfrom(MAX_SIZE)}
+        ip_address = addr[3]
+        message = Message.load(data)
+        return [ip_address, message]
+      rescue TypeError, NoMethodError
+        ip_address = ip_address || "(unknown)"
+        Log::Debug.notification("Invalid data has been received from %s." % ip_address)
+        retry
+      end
+
+      # Close and open receiver socket.
+      def reopen
+        close
+        open(@host, @port)
+      end
+
+      # Close the receiver socket.
+      def close
+        @socket.close
+      end
+
+      # Return true if receiver socket is closed.
+      #
+      # @return [Boolean]
+      #   true if receiver socket is closed
+      def closed?
+        @socket.closed?
+      end
+
+      private
+
+      # Open a receiver socket with the port number. Be careful that Linux seems
+      # to require INADDR_ANY to receive broadcast packets, and Windows seems
+      # not to require.
+      #
+      # @return [void]
+      def open
+        _host = IPSocket.getaddress(@uri.host)
+
+        @socket = UDPSocket.open
+        @socket.bind(_host, @uri.port)
+
+        case @uri.scheme
+        when "pnb"
+          unless not(OS.windows?) and IPAddr.new(_host) == Socket::INADDR_ANY
+            msg = [
+              "Notification receiver address %p is not INADDR_ANY(%p), ",
+              "this may cause to fail receiving broadcast packets. ",
+              "If you can receive it, please tell me your platform name."
+            ].join
+            Log::SystemLog.warn(msg % [@uri.host, "0.0.0.0"])
+          end
+
+          @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
+        when "pnm"
+          group = IPAddr.new(@uri.host).hton
+          if @uri.interface
+            interface = IPAddr.new(@uri.interface).hton
+          else
+            interface = IPAddr.new(Addrinfo.ip(Socket::INADDR_ANY).ip_address).hton
+          end
+          @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, group + interface)
+        end
+      end
+    end
+  end
+end