pione 0.3.2 → 0.4.0

data/lib/pione/agent/job-terminator.rb

@@ -5,8 +5,8 @@ module Pione
     class JobTerminator < TupleSpaceClient
       set_agent_type :job_terminator, self
 
-      def initialize(space, &b)
-        super(space)
+      def initialize(tuple_space, &b)
+        super(tuple_space)
         @action = b
       end
 

data/lib/pione/agent/logger.rb

@@ -9,8 +9,8 @@ module Pione
       attr_reader :output_location # output location
 
       # Create a logger agent.
-      def initialize(space, location)
-        super(space)
+      def initialize(tuple_space, location)
+        super(tuple_space)
         @log_id = Time.now.iso8601(3)
         @log_location = location.directory? ? location + "pione-process.log" : location
         @output_location = get_output_location
@@ -73,7 +73,7 @@ module Pione
         if @log_location.real_appendable?
           @log_location
         else
-          Location[Pione.temporary_path(@log_location.basename)]
+          Location[Temppath.mkdir + @log_location.basename]
         end
       end
     end

data/lib/pione/agent/messenger.rb

@@ -4,27 +4,38 @@ module Pione
     class Messenger < TupleSpaceClient
       set_agent_type :messenger, self
 
+      # @param tuple_space [TupleSpace::TupleSpaceServer]
+      #   tuple space
+      # @param receiver [Log::MessageLogReceiver]
+      #   message log receiver
+      def initialize(tuple_space, receiver)
+        super(tuple_space)
+
+        # message log receiver
+        @receiver = receiver
+      end
+
       #
       # agent activities
       #
 
-      define_transition :print
+      define_transition :pass
 
-      chain :init => :print
-      chain :print => :print
+      chain :init => :pass
+      chain :pass => :pass
 
       #
       # transitions
       #
 
-      # Transits to the state +print+.
-      def transit_to_print
+      # Transits to the state `pass`.
+      def transit_to_pass
         tuples = take_all(TupleSpace::MessageTuple.any)
         tuples.sort{|a,b| a.timestamp <=> b.timestamp}.each do |tuple|
-          msgs = tuple.contents
-          msgs = [msgs] if tuple.contents.kind_of?(String)
-          msgs.each do |msg|
-            puts "%s%s %s" % ["  "*tuple.level, ("%5s" % tuple.head).color(tuple.color), msg]
+          tuple.contents.tap do |contents|
+            (contents.kind_of?(String) ? [contents] : contents).each do |msg|
+              @receiver.receive(msg, tuple.level, tuple.head, tuple.color)
+            end
           end
         end
       end

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

@@ -0,0 +1,88 @@
+module Pione
+  module Agent
+    class NotificationListener < BasicAgent
+      #
+      # instance methods
+      #
+
+      # notification handler threads
+      attr_reader :notification_handlers
+
+      # @param model [NotificationListenerModel]
+      #   notification-listner model
+      # @param uri [URI]
+      #   listening port
+      def initialize(model, uri)
+        super()
+        @uri = uri
+        @model = model
+        @notification_handlers = ThreadGroup.new
+        @lock = Mutex.new
+      end
+
+      #
+      # agent activities
+      #
+
+      define_transition :receive
+
+      chain :init => :receive
+      chain :receive => :receive
+
+      #
+      # transitions
+      #
+
+      # Initialize the agent.
+      def transit_to_init
+        Log::SystemLog.info('Notification listener starts listening notification messages on "%s".' % @uri)
+        @receiver = Notification::Receiver.new(@uri)
+      end
+
+      # Receive notification messages and make a message handler thread.
+      def transit_to_receive
+        # receive a notification
+        transmitter_host, message = @receiver.receive
+
+        # handle the notification in new thread
+        thread = Util::FreeThreadGenerator.generate do
+          handle_notification(transmitter_host, message)
+        end
+        @notification_handlers.add(thread)
+      rescue StandardError => e
+        Log::Debug.notification("Receiver agent has received bad data from %s, so it ignored and reopen socket." % ip_address)
+        @receiver.reopen
+      end
+
+      # Close receiver socket.
+      def transit_to_terminate
+        # kill threads of notification handler
+        @notification_handlers.list.each {|thread| thread.kill.join}
+        # close socket
+        @receiver.close unless @receiver.closed?
+      end
+
+      #
+      # helper method
+      #
+
+      private
+
+      # Notify the notification message to recipients.
+      def handle_notification(transmitter_host, message)
+        # notify the message to recepients
+        bad_recipients = @model.recipients.each_with_object([]) do |uri, bad_recipients|
+          begin
+            Timeout.timeout(3) {DRb::DRbObject.new_with_uri(uri).notify(message)}
+          rescue Timeout::Error, DRb::DRbConnError, DRbPatch::ReplyReaderError => e
+            Log::Debug.notification("Notification recipient %s disconnected: %s" % [uri, e.message])
+            bad_recipients << uri
+          end
+        end
+
+        # delete bad recipients
+        @model.delete_recipient(*bad_recipients)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Pione
+  module Agent
+    # `TaskWorkerBroker` is an agent for providing task workers to tuple spaces.
+    class TaskWorkerBroker < BasicAgent
+      set_agent_type :task_worker_broker, self
+
+      #
+      # instance methods
+      #
+
+      def initialize(model)
+        super()
+        @model = model
+        @provider = Global.task_worker_provider.new(model)
+      end
+
+      #
+      # activity definitions
+      #
+
+      define_transition :count_tuple_space
+      define_transition :provide_task_worker
+      define_transition :sleep
+      define_transition :check_tuple_space
+      define_transition :check_task_worker_life
+
+      chain :init => [:count_tuple_space, :check_task_worker_life]
+      chain :count_tuple_space => lambda {|agent, res|
+        res > 0 ? :provide_task_worker : :sleep
+      }
+      chain :provide_task_worker => lambda {|agent, rebalance|
+        rebalance ? :provide_task_worker : :sleep
+      }
+      chain :sleep => :count_tuple_space
+      chain :check_tuple_space => :count_tuple_space
+      chain :check_task_worker_life => :check_task_worker_life
+
+      define_exception_handler Restart => :check_tuple_space
+
+      #
+      # transitions
+      #
+
+      def transit_to_init
+        Log::SystemLog.info "Task worker broker starts the activity."
+      end
+
+      def transit_to_count_tuple_space
+        @model.tuple_space.size
+      end
+
+      def transit_to_provide_task_worker
+        @provider.provide
+      end
+
+      def transit_to_check_tuple_space
+        @model.check_tuple_space
+      end
+
+      def transit_to_sleep
+        if @model.tuple_space.size == 0 or @model.excess_task_workers == 0
+          sleep Global.task_worker_broker_long_sleep_time
+        else
+          sleep Global.task_worker_broker_short_sleep_time
+        end
+      end
+
+      def transit_to_check_task_worker_life
+        @model.delete_dead_task_workers
+        sleep Global.task_worker_broker_short_sleep_time
+      end
+
+      # Send bye messages to tuple spaces when the agent is terminated.
+      def transit_to_terminate
+        @model.tuple_space_lock.synchronize do
+          @model.tuple_spaces.each do |tuple_space|
+            Util.ignore_exception {timeout(1) {tuple_space.bye}}
+          end
+        end
+        Log::SystemLog.info "Task worker broker ends the activity."
+      end
+    end
+  end
+end

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

@@ -77,8 +77,9 @@ module Pione
         @execution_thread = Thread.new do
           begin
             engine.handle
-          rescue RuleEngine::ActionError, Lang::MethodNotFound => e
-            write(TupleSpace::CommandTuple.new("terminate", [System::Status.error(e)]))
+          rescue RuleEngine::RuleExecutionError, Lang::LangError => e
+            user_message("ERROR: " + e.message, 0, "info", :red)
+            write(TupleSpace::CommandTuple.new(name: "terminate", args: [System::Status.error(e.message)]))
             terminate
           end
         end

data/lib/pione/agent/tuple-space-client.rb

@@ -69,6 +69,7 @@ module Pione
     class TupleSpaceClient < BasicAgent
       include TupleSpace::TupleSpaceInterface
       include TupleSpaceClientOperation
+      include Log::MessageLog
 
       # Initialize agent's state.
       def initialize(tuple_space)

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

@@ -1,6 +1,7 @@
 module Pione
   module Agent
-    # TupleSpaceProvider is an agent that provides tuple space.
+    # TupleSpaceProvider is an agent that provides a URI of tuple space as
+    # notification messages.
     class TupleSpaceProvider < BasicAgent
       set_agent_type :tuple_space_provider, self
 
@@ -8,59 +9,40 @@ module Pione
       # instance methods
       #
 
-      def initialize(front)
+      # @param provider [URI]
+      #   URI of the tuple space
+      # @param targets [Array<URI>]
+      #   target URIs
+      def initialize(uri, targets=Global.notification_targets)
         super()
-        @front = front
-        @reference = Marshal.dump(/druby:\/\/(.*):(\d+)/.match(@front.uri)[2].to_i)
+        @targets = targets
+        @notification = Notification::Message.new(
+          "TUPLE_SPACE_PROVIDER", "TUPLE_SPACE", {"front" => uri}
+        )
       end
 
       #
       # agent activities
       #
 
-      define_transition :send_packet
+      define_transition :send_message
       define_transition :sleep
 
-      chain :init => :send_packet
-      chain :send_packet => :sleep
-      chain :sleep => :send_packet
+      chain :init => :send_message
+      chain :send_message => :sleep
+      chain :sleep => :send_message
 
       #
       # transitions
       #
 
-      def transit_to_send_packet
-        send_packet
+      def transit_to_send_message
+        Notification::Transmitter.transmit(@notification, @targets)
       end
 
       def transit_to_sleep
         sleep 5
       end
-
-      #
-      # helper methods
-      #
-
-      # Send presence notification packets to tuple space receivers.
-      def send_packet
-        # open a UDP socket
-        socket = UDPSocket.open
-        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1)
-
-        # send broadcast packets
-        Global.presence_notification_addresses.each do |address|
-          begin
-            Log::Debug.presence_notification do
-              "provider sends presence notification packet from %s to %s" % [@front.uri, address, Time.now]
-            end
-            socket.send(@reference, 0, address.host, address.port)
-          rescue => e
-            Log::SystemLog.warn("tuple space provider agent failed to send a packet: %s" % e.message)
-          end
-        end
-      ensure
-        socket.close
-      end
     end
   end
 end

data/lib/pione/command.rb

@@ -1,28 +1,46 @@
 module Pione
   # Command is a name space for PIONE command classes.
-  module Command; end
+  module Command
+    def self.load_all
+      require 'pione/command/pione-action'
+      require 'pione/command/pione-action-exec'
+      require 'pione/command/pione-action-list'
+      require 'pione/command/pione-action-print'
+      require 'pione/command/pione-clean'
+      require 'pione/command/pione-compile'
+      require 'pione/command/pione-config'
+      require 'pione/command/pione-config-get'
+      require 'pione/command/pione-config-list'
+      require 'pione/command/pione-config-set'
+      require 'pione/command/pione-config-unset'
+      require 'pione/command/pione-diagnosis'
+      require 'pione/command/pione-diagnosis-notification'
+      require 'pione/command/pione-lang'
+      require 'pione/command/pione-lang-check-syntax'
+      require 'pione/command/pione-log'
+      require 'pione/command/pione-log-format'
+      require 'pione/command/pione-log-list-id'
+      require 'pione/command/pione-package'
+      require 'pione/command/pione-package-add'
+      require 'pione/command/pione-package-build'
+      require 'pione/command/pione-package-show'
+      require 'pione/command/pione-package-update'
+    end
+  end
 end
 
 require 'pione/command/command-exception'
+require 'pione/command/common'
 require 'pione/command/spawner'
 require 'pione/command/option'
+require 'pione/command/action'
 require 'pione/command/basic-command'
 require 'pione/command/pione-command'
 require 'pione/command/pione-client'
 require 'pione/command/pione-task-worker'
-require 'pione/command/pione-broker'
+require 'pione/command/pione-task-worker-broker'
 require 'pione/command/pione-tuple-space-provider'
-require 'pione/command/pione-tuple-space-receiver'
+require 'pione/command/pione-notification-listener'
 require 'pione/command/pione-tuple-space-viewer'
-require 'pione/command/pione-relay'
-require 'pione/command/pione-relay-client-db'
-require 'pione/command/pione-relay-account-db'
-require 'pione/command/pione-clean'               # pione clean
-require 'pione/command/pione-syntax-checker'
-require 'pione/command/pione-log'                 # pione log
-require 'pione/command/pione-val'                 # pione-val
-require 'pione/command/pione-package'
-require 'pione/command/pione-compiler'
-require 'pione/command/pione-update-package-info' # pione update-package-info
-require 'pione/command/pione-action'              # pione action
-require 'pione/command/pione-action-list'         # pione action:list
+require 'pione/command/pione-val'
+

data/lib/pione/command/action.rb

@@ -0,0 +1,105 @@
+module Pione
+  module Command
+    # `InitAction` is a set of actions for PIONE commands initialization.
+    module InitAction
+      extend Rootage::ActionCollection
+
+      define(:front) do |item|
+        item.desc = "Initialize a front server"
+
+        item.assign(:front) do
+          test(cmd.info[:front])
+
+          cmd.info[:front].new(cmd)
+        end
+      end
+    end
+
+    module CommonAction
+      extend Rootage::ActionCollection
+
+      define(:load_domain_dump) do |item|
+        item.desc = "Load a domain dump file"
+
+        item.assign(:domain_dump) do
+          test(model[:domain_dump_location])
+
+          if model[:domain_dump_location]
+            System::DomainDump.load(model[:domain_dump_location])
+          else
+            cmd.abort('Domain dump "%s" not found.' % model[:domain_dump_location].uri)
+          end
+        end
+      end
+    end
+
+    module ProcessAction
+      extend Rootage::ActionCollection
+
+      define(:connect_parent) do |item|
+        item.desc = "Setup parent process connection"
+
+        item.process do
+          test(cmd.option_definition.find_item(:parent_front).requisite)
+          test(not(model.specified?(:parent_front)))
+          raise System::PioneBug.new("%{cmd} needs --parent-front" % {cmd: cmd.name})
+        end
+
+        item.process do
+          test(model[:parent_front])
+          model[:parent_front].register_child(Process.pid, model[:front].uri)
+
+          # delegate system logger
+          Global.system_logger = Log::DelegatableLogger.new(model[:parent_front].system_logger)
+
+          # start to watch parent process
+          Thread.new do
+            while true
+              # PPID 1 means the parent process is dead
+              if Process.ppid == 1 or Util.error?{model[:parent_front].ping}
+                break cmd.terminate
+              end
+              sleep 1
+            end
+          end
+        end
+
+        item.exception(Front::ChildRegistrationError) do |e|
+          cmd.terminate
+        end
+      end
+
+      define(:disconnect_parent) do |item|
+        item.desc = "Terminate parent process connection"
+
+        item.process do
+          test(model[:parent_front])
+
+          # maybe parent process is dead in this timing
+          Util.ignore_exception do
+            model[:parent_front].unregister_child(Process.pid)
+          end
+        end
+      end
+
+      define(:terminate_children) do |item|
+        item.desc = "Terminate child processes"
+
+        item.process do
+          Sys::ProcTable.ps.select {|ps|
+            if ps.ppid == Process.pid
+              Util.ignore_exception {Process.kill(:TERM, ps.pid)}
+            end
+          }
+
+          # wait all children
+          children = Process.waitall.map{|(pid, _)| pid}
+          if not(children.empty?)
+            arg = {name: cmd.name, pid: children.join(", ")}
+            Log::Debug.system('"%{name}" has killed #%{pid}' % arg)
+          end
+        end
+      end
+    end
+  end
+end