pione 0.3.2 → 0.4.0

data/lib/pione/front.rb

@@ -5,9 +5,11 @@ end
 
 require 'pione/front/front-exception'
 require 'pione/front/basic-front'
+require 'pione/front/notification-recipient-interface'
 require 'pione/front/client-front'
-require 'pione/front/broker-front'
 require 'pione/front/task-worker-front'
+require 'pione/front/task-worker-broker-front'
 require 'pione/front/tuple-space-provider-front'
-require 'pione/front/tuple-space-receiver-front'
+require 'pione/front/notification-listener-front'
 require 'pione/front/relay-front'
+require 'pione/front/diagnosis-notification-front'

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

@@ -1,19 +1,20 @@
 module Pione
   module Front
     # This is base class for all PIONE front classes. PIONE fronts exist in each
-    # command and behave as remote interface.
+    # command and behave as remote control interface.
     class BasicFront < PioneObject
       include DRbUndumped
 
       attr_reader :uri   # front server's URI string
-      attr_reader :attrs
-      attr_reader :child # child process table
 
       # Creates a front server as druby's service.
-      def initialize(port)
-        @uri = start_service(port, {}) # port is number or range
-        @attrs = {}
+      def initialize(cmd, port)
+        @cmd = cmd
+        @uri = URI.parse(start_service(port, {})) # port is number or range
+        @attr = {}
         @child = {}
+        @child_lock = Mutex.new
+        @child_watchers = ThreadGroup.new
       end
 
       # Return PID of the process.
@@ -22,26 +23,82 @@ module Pione
       end
 
       def [](name)
-        @attrs[name]
+        @attr[name]
       end
 
       def []=(name, val)
-        @attrs[name] = val
+        @attr[name] = val
       end
 
-      # Add child process.
-      def add_child(pid, front_uri)
-        @child[pid] = front_uri
+      # Register the process as a child of this process. It is unregistered when
+      # the child is terminated.
+      #
+      # @param pid [String]
+      #   child process's PID
+      # @param front_uri [String]
+      #   child process's front URI
+      # @return [void]
+      def register_child(pid, front_uri)
+        unless @cmd.current_phase == :termination
+          # register child's PID
+          @child_lock.synchronize {@child[pid] = front_uri}
+
+          # unregister automatically when the child is terminated
+          thread = Thread.new do
+            Util.ignore_exception(Errno::ECHILD) do
+              Process.waitpid(pid)
+              unregister_child(pid)
+            end
+          end
+          thread[:pid] = pid
+          @child_watchers.add(thread)
+
+          return nil
+        else
+          raise ChildRegistrationError.new
+        end
+      end
+
+      # Unregister the child process.
+      #
+      # @param pid [String]
+      #   child's PID to be removed
+      def unregister_child(pid)
+        # unregister the pid
+        @child_lock.synchronize {@child.delete(pid)}
+
+        # kill the watcher thread
+        @child_watchers.list.each do |thread|
+          if thread[:pid] == pid
+            thread.kill
+            break
+          end
+        end
+      end
+
+      # Return list of child process's PIDs.
+      #
+      # @return [Array]
+      #   list of child command's PIDs.
+      def child_pids
+        @child.keys
       end
 
-      # Delete child process.
-      def remove_child(pid)
-        @child.delete(pid)
+      # Return a front URI of the child PID.
+      #
+      # @return [String]
+      #   URI of the child PID
+      def child_front_uri(pid)
+        @child[pid]
+      end
+
+      def system_logger
+        Log::SystemLog.logger
       end
 
       # Terminate the front server. This method assumes to be not called from
-      # other process. Note that front servers have no responsibility of killing
-      # child processes.
+      # other processes. Note that front servers have no responsibility of
+      # killing child processes.
       def terminate
         DRb.stop_service
       end
@@ -50,7 +107,7 @@ module Pione
       # process cannot tell its termination to caller, so it returns true
       # immediately.
       def terminate_command
-        Thread.new {Global.command.terminate}
+        Thread.new {@cmd.terminate}
         return true
       end
 
@@ -61,25 +118,31 @@ module Pione
         if port.kind_of?(Range)
           enum = port.each
           begin
-            DRb.start_service(build_front_server_uri(enum.next), self, config)
+            DRb.start_service(build_uri(enum.next), self, config)
           rescue StopIteration => e
             raise
           rescue
             retry
           end
         else
-          DRb.start_service(build_front_server_uri(port), self, config)
+          DRb.start_service(build_uri(port), self, config)
         end
 
         return DRb.uri
       rescue => e
-        raise FrontError.new(self, e)
+        raise FrontServerError.new(self, e)
+      end
+
+      # This provides non blocking API.
+      def non_blocking(&b)
+        Thread.new {b.call}
+        return nil
       end
 
       # Build front server URI. Note that the address is configured by
-      # +Global.my_ip_address+.
-      def build_front_server_uri(port)
-        "druby://%s:%s" % [Global.my_ip_address, port]
+      # `Global.communication_address`.
+      def build_uri(port)
+        "druby://%s:%s" % [Global.communication_address, port]
       end
     end
   end

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

@@ -3,8 +3,8 @@ module Pione
     # ClientFront is a front interface for +pione-client+ command.
     class ClientFront < BasicFront
       # Create a new front.
-      def initialize
-        super(Global.client_front_port_range)
+      def initialize(cmd)
+        super(cmd, Global.client_front_port_range)
       end
 
       def set_tuple_space(tuple_space)

data/lib/pione/front/diagnosis-notification-front.rb

@@ -0,0 +1,40 @@
+module Pione
+  module Front
+    # `DiagnosisNotificationFront` is a front server for diagnosis test about
+    # sending notifications.
+    class DiagnosisNotificationFront < BasicFront
+      LOCK = Mutex.new
+
+      def initialize(cmd)
+        super(cmd, Global.diagnosis_notification_front_port_range)
+        @transmitting_threads = ThreadGroup.new
+      end
+
+      # If the front is touched, notification diagnosis is success.
+      #
+      # @param transmitter_id [String]
+      #   transmitter ID, this is a string of transmitter's target URI
+      # @return [void]
+      def touch(transmitter_id)
+        LOCK.synchronize do
+          @transmitting_threads.list.each do |thread|
+            if thread[:transmitter_id] == transmitter_id and thread.alive?
+              thread.terminate
+            end
+          end
+        end
+        return true
+      end
+
+      # Register the transmitting thread for test.
+      #
+      # @param thread [Thread]
+      #   a transmitting thread,
+      #   see `Pione::Command::PioneDiagnosisNotification`
+      # @return [void]
+      def register_transmitting_thread(thread)
+        LOCK.synchronize {@transmitting_threads.add(thread)}
+      end
+    end
+  end
+end

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

@@ -1,7 +1,10 @@
 module Pione
   module Front
+    # `Front::Error` is a base exception class.
+    class Error < StandardError; end
+
     # FrontError is raised when front server cannnot start.
-    class FrontError < StandardError
+    class FrontServerError < Error
       def initialize(front, exception)
         @front = front
         @exception = exception
@@ -12,5 +15,8 @@ module Pione
       end
     end
 
+    # `ChildRegistrationError` is raised when child process failed to register to
+    # parent front.
+    class ChildRegistrationError < Error; end
   end
 end

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

@@ -0,0 +1,36 @@
+module Pione
+  module Front
+    # `NotificationListenerFront` is a front interface for
+    # `pione-notification-listener` command.
+    class NotificationListenerFront < BasicFront
+      def initialize(cmd)
+        super(cmd, Global.notification_listener_front_port)
+      end
+
+      # Add the recipient that receives notification messages.
+      #
+      # @param uri [String]
+      #   URI of the recipent's front
+      # @param recipient [Notification::Recipient]
+      #   the recipient that receives notification messages
+      # @return [void]
+      def add(uri)
+        non_blocking do
+          @cmd.model.add_recipient(uri)
+          Log::SystemLog.debug 'Recipient "%s" has been added.' % uri
+        end
+      end
+
+      # Delete the recipient that receives notification messages.
+      #
+      # @param uri [String]
+      #   URI of the recipent's front
+      def delete(uri)
+        non_blocking do
+          @cmd.model.delete_recipient(uri)
+          Log::SystemLog.debug 'Recipient "%s" has been deleted.' % uri
+        end
+      end
+    end
+  end
+end

data/lib/pione/front/notification-recipient-interface.rb

@@ -0,0 +1,19 @@
+module Pione
+  module Front
+    module NotificationRecipientInterface
+      def set_recipient(recipient)
+        @__recipient__ = recipient
+      end
+
+      # Notify the notification message to the recipient. This method is
+      # non-blocking.
+      #
+      # @param message [Notification::Message]
+      #   notification message
+      # @return [void]
+      def notify(message)
+        non_blocking {@__recipient__.notify(message)}
+      end
+    end
+  end
+end

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

@@ -1,17 +1,17 @@
 module Pione
   module Front
     class RelayFront < BasicFront
-      attr_reader :presence_port
+      attr_reader :notification_port
       attr_reader :tuple_space_server
 
       # Create a new front.
-      def initialize(presence_port, tuple_space)
+      def initialize(notification_port, tuple_space)
         super(Global.relay_front_port_range)
-        @presence_port = presence_port
+        @notification_port = notification_port
         @tuple_space = tuple_space
       end
 
-      def presence_notifier
+      def notifier
         tuple_space_provider
       end
     end

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

@@ -0,0 +1,19 @@
+module Pione
+  module Front
+    # `TaskWorkerBrokerFront` is a front interface for
+    # `pione-task-worker-broker` command.
+    class TaskWorkerBrokerFront < BasicFront
+      # this receives notification messages
+      include NotificationRecipientInterface
+
+      def initialize(cmd)
+        super(cmd, Global.task_worker_broker_front_port_range)
+        set_recipient(Notification::TaskWorkerBrokerRecipient.new(cmd.model, uri, Global.notification_listener))
+      end
+
+      def get_tuple_space(tuple_space_id)
+        @cmd.model.get_tuple_space(tuple_space_id)
+      end
+    end
+  end
+end

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

@@ -2,8 +2,8 @@ module Pione
   module Front
     # TaskWorkerFront is a front interface for pione-task-worker command.
     class TaskWorkerFront < BasicFront
-      def initialize
-        super(Global.task_worker_front_port_range)
+      def initialize(cmd)
+        super(cmd, Global.task_worker_front_port_range)
       end
     end
   end

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

@@ -5,8 +5,9 @@ module Pione
     class TupleSpaceProviderFront < BasicFront
       attr_reader :tuple_space
 
-      def initialize(tuple_space)
-        super(Global.tuple_space_provider_front_port_range)
+      def initialize(cmd)
+        tuple_space = cmd.model[:parent_front].get_tuple_space(nil)
+        super(cmd, Global.tuple_space_provider_front_port_range)
         @tuple_space = tuple_space
       end
     end

data/lib/pione/global.rb

@@ -5,6 +5,7 @@ module Pione
   module Global; end
 end
 
+require 'pione/global/global-exception'
 require 'pione/global/item'
 require 'pione/global/config'
 require 'pione/global/system-variable'
@@ -14,7 +15,8 @@ require 'pione/global/log-variable'
 require 'pione/global/relay-variable'
 require 'pione/global/client-variable'
 require 'pione/global/task-worker-variable'
-require 'pione/global/broker-variable'
+require 'pione/global/task-worker-broker-variable'
 require 'pione/global/input-generator-variable'
 require 'pione/global/tuple-space-notifier-variable'
 require 'pione/global/package-variable'
+require 'pione/global/diagnosis-variable'

data/lib/pione/global/client-variable.rb

@@ -14,7 +14,7 @@ module Pione
 
     # This is port range for client's front.
     define_computed_item(:client_front_port_range, [:client_front_port_range_begin, :client_front_port_range_end]) do |item|
-      item.desc = "port range of broker front"
+      item.desc = "port range of client front"
       item.define_updater do
         Range.new(
           Global.client_front_port_range_begin,

data/lib/pione/global/config.rb

@@ -7,7 +7,7 @@ module Pione
         new(path).tap {|x| x.apply}
       end
 
-      forward :@table, "[]"
+      forward! :@table, "[]", "each"
 
       # config file path
       attr_reader :path
@@ -15,21 +15,77 @@ module Pione
       # Create a new configuration.
       def initialize(path)
         @path = Pathname.new(path)
-        @table = @path.exist? ? YAML.load(@path.read) : {}
+        @table = Hash.new
+        (@path.exist? ? JSON.load(@path.read) : {}).each do |key, val|
+          @table[key.to_sym] = val
+        end
         raise InvalidConfigFile.new(@path) unless @table.kind_of?(Hash)
       end
 
       # Apply config date to global settings.
       def apply
         @table.each do |key, val|
-          key = key.to_sym
-          if Global.item[key] and Global.item[key].configurable?
-            Global.set(key, val)
-          else
-            raise UnconfigurableVariableError.new(key)
+          name = key.to_sym
+          if_configurable_item(name) do
+            Global.set(name, val)
           end
         end
       end
+
+      # Set the global item.
+      #
+      # @param name [String]
+      #   item name
+      # @param value [Object]
+      #   item value
+      # @return [void]
+      def set(name, value)
+        raise ArgumentError.new if value.nil?
+
+        name = name.to_sym
+        if_configurable_item(name) do
+          @table[name] = ValueConverter.convert(Global.item[name].type, value)
+        end
+      end
+
+      # Get the global item's value.
+      #
+      # @param name [String]
+      #   item name
+      # @return [Object]
+      #   item value
+      def get(name)
+        name = name.to_sym
+        if_configurable_item(name) do
+          @table[name]
+        end
+      end
+
+      def unset(name)
+        name = name.to_sym
+        @table.delete(name)
+      end
+
+      # Save the configuration items to the file.
+      #
+      # @param path [Pathname]
+      #   file path
+      # @return [void]
+      def save(path=@path)
+        path.open("w+") do |file|
+          file.write(JSON.pretty_generate(@table))
+        end
+      end
+
+      private
+
+      def if_configurable_item(name, &b)
+        if Global.item[name] and Global.item[name].configurable?
+          b.call
+        else
+          raise UnconfigurableVariableError.new(name)
+        end
+      end
     end
   end
 end