drbqs 0.0.13 → 0.0.14

data/lib/drbqs/server/message.rb

@@ -0,0 +1,142 @@
+require 'drbqs/server/node_list'
+
+module DRbQS
+  class Server
+    class Message
+      include DRbQS::Misc
+
+      def initialize(message, logger = DRbQS::LoggerDummy.new)
+        @message = message
+        @node_list = DRbQS::Server::NodeList.new
+        @logger = logger
+      end
+
+      def get_message
+        begin
+          mes = @message.take([:server, Symbol, nil], 0)
+          manage_message(*mes[1..2])
+        rescue Rinda::RequestExpiredError
+          nil
+        end
+      end
+
+      def manage_message(mes, arg)
+        @logger.info("Get message") { [mes, arg] }
+        case mes
+        when :connect
+          a = [arg, @node_list.get_new_id(arg)]
+          @logger.info("New node") { a }
+          @message.write(a)
+        when :alive
+          @node_list.set_alive(arg)
+        when :exit_server
+          @logger.info("Get exit message from #{arg.to_s}")
+        when :exit_after_task
+          @logger.info("Get exit message for node #{arg.to_s} after current task")
+          return [mes, arg]
+        when :request_status
+          @logger.info("Get status request from #{arg.to_s}")
+        when :node_error
+          @node_list.delete(arg[0])
+          @logger.info("Node Error (#{arg[0]})") { arg[1] }
+          return [mes, arg[0]]
+        else
+          @logger.error("Invalid message from #{arg.to_s}")
+          return nil
+        end
+        [mes]
+      end
+      private :manage_message
+
+      def check_connection
+        deleted = @node_list.delete_not_alive
+        @logger.info("IDs of deleted nodes") { deleted } if deleted.size > 0 && @logger
+        @node_list.each do |id, str|
+          @message.write([id, :alive_p])
+        end
+        @node_list.set_check_connection
+        deleted
+      end
+
+      def send_signal(node_id, signal)
+        @message.write([node_id, signal])
+      end
+      private :send_signal
+
+      def send_signal_to_all_nodes(signal)
+        @node_list.each do |node_id, id_str|
+          send_signal(node_id, signal)
+        end
+      end
+      private :send_signal_to_all_nodes
+
+      # Send all nodes a message to exit.
+      def send_exit
+        send_signal_to_all_nodes(:exit)
+      end
+
+      # Send all nodes a message to finalize and exit.
+      def send_finalization
+        send_signal_to_all_nodes(:finalize)
+      end
+
+      def send_exit_after_task(node_id)
+        send_signal(node_id, :exit_after_task)
+      end
+
+      def send_status(calculating_task_id)
+        s = ''
+        @node_list.history.each do |node_id, events|
+          if events.size == 0 || events.size > 2
+            raise "Invalid history of nodes: #{events.inspect}"
+          end
+          connect = events[0]
+          s << sprintf("%4d %s\t", node_id, connect[2])
+          if disconnect = events[1]
+            s << "disconnected: (#{time_to_history_string(connect[0])} - #{time_to_history_string(disconnect[0])})\n"
+          else
+            task_ids = calculating_task_id[node_id].to_a
+            s << "task: #{task_ids.map { |num| num.to_s }.join(', ')} (#{time_to_history_string(connect[0])})\n"
+          end
+        end
+        begin
+          @message.take([:status, nil], 0)
+        rescue Rinda::RequestExpiredError
+        end
+        @message.write([:status, s])
+      end
+
+      def get_all_nodes
+        @node_list.list.dup
+      end
+
+      def node_not_exist?
+        @node_list.empty?
+      end
+
+      def node_exist?(node_id)
+        @node_list.exist?(node_id)
+      end
+
+      def set_special_task(label, task)
+        begin
+          @message.take([label, nil, Symbol, nil], 0)
+        rescue Rinda::RequestExpiredError
+        end
+        @message.write(task.drb_args(label))
+      end
+      private :set_special_task
+
+      # If the task has already set,
+      # the method overwrite old task of initialization by new task.
+      def set_initialization(task)
+        set_special_task(:initialize, task)
+      end
+
+      def set_finalization(task)
+        set_special_task(:finalization, task)
+      end
+    end
+
+  end
+end

data/lib/drbqs/server/node_list.rb

@@ -0,0 +1,59 @@
+require 'drbqs/server/history'
+
+module DRbQS
+  class Server
+    class NodeList
+      attr_reader :history, :list
+
+      def initialize
+        @id = 0
+        @list = {}
+        @check = []
+        @history = DRbQS::Server::History.new
+      end
+
+      def get_new_id(id_str)
+        @id += 1
+        @list[@id] = id_str
+        @history.set(@id, :connect, @list[@id])
+        @id
+      end
+
+      def each(&block)
+        @list.each(&block)
+      end
+
+      def set_check_connection
+        @check = @list.keys
+      end
+
+      def delete(id)
+        @list.delete(id)
+        @history.set(id, :disconnect)
+      end
+
+      def delete_not_alive
+        @check.each do |id|
+          delete(id)
+        end
+        deleted = @check
+        @check = []
+        deleted
+      end
+
+      def set_alive(id)
+        @check.delete(id)
+      end
+
+      def empty?
+        @list.size == 0
+      end
+
+      def exist?(id)
+        @list.find { |a| a[0] == id }
+      end
+    end
+
+  end
+end
+

data/lib/drbqs/server/queue.rb

@@ -0,0 +1,128 @@
+require 'drbqs/server/history'
+
+module DRbQS
+
+  class Server
+    class Queue
+      attr_reader :calculating, :history
+
+      def initialize(queue, result, logger = DRbQS::LoggerDummy.new)
+        @queue = queue
+        @result = result
+        @task_id = 0
+        @cache = {}
+        @calculating = Hash.new { |hash, key| hash[key] = Array.new }
+        @history = DRbQS::Server::History.new
+        @logger = logger
+      end
+
+      def queue_task(task_id)
+        @queue.write(@cache[task_id].drb_args(task_id))
+      end
+      private :queue_task
+
+      # &hook take two arguments: a DRbQS::Server::Queue object and a result of task.
+      # Return task ID (for debug).
+      def add(task)
+        @task_id += 1
+        @logger.info("New task: #{@task_id}")
+        @cache[@task_id] = task
+        queue_task(@task_id)
+        @history.set(@task_id, :add)
+        @task_id
+      end
+
+      def get_accept_signal
+        count = 0
+        begin
+          loop do
+            sym, task_id, node_id = @result.take([:accept, Fixnum, Fixnum], 0)
+            count += 1
+            @calculating[node_id] << task_id
+            @history.set(task_id, :calculate, node_id)
+            @logger.info("Accept: task #{task_id} by node #{node_id}.")
+          end
+        rescue Rinda::RequestExpiredError
+          @logger.debug("Accept: #{count} signals.")
+        end
+        count
+      end
+
+      def requeue_for_deleted_node_id(deleted)
+        deleted.each do |node_id|
+          if task_id_ary = @calculating[node_id]
+            task_id_ary.each do |task_id|
+              queue_task(task_id)
+              @history.set(task_id, :requeue)
+              @logger.info("Requeue: task #{task_id}.")
+            end
+            @calculating.delete(node_id)
+          end
+        end
+      end
+
+      def delete_task_id(node_id, task_id)
+        unless @calculating[node_id].delete(task_id)
+          @logger.error("Task #{task_id} does not exist in list of calculating tasks.")
+        end
+        if ary = @calculating.find { |k, v| v.include?(task_id) }
+          @logger.error("Node #{ary[0]} is calculating task #{task_id}, too.")
+        end
+      end
+      private :delete_task_id
+
+      def exec_task_hook(main_server, task_id, result)
+        if task = @cache.delete(task_id)
+          if task.exec_hook(main_server, result)
+            @history.set(task_id, :hook)
+          end
+          true
+        else
+          @logger.error("Task #{task_id} is not cached.")
+          false
+        end
+      end
+
+      def get_result(main_server)
+        count = 0
+        begin
+          loop do
+            get_accept_signal
+            sym, task_id, node_id, result = @result.take([:result, Fixnum, Fixnum, nil], 0)
+            count += 1
+            @history.set(task_id, :result, node_id)
+            @logger.info("Get: result of #{task_id} from node #{node_id}.")
+            delete_task_id(node_id, task_id)
+            exec_task_hook(main_server, task_id, result)
+          end
+        rescue Rinda::RequestExpiredError
+          @logger.debug("Get: #{count} results.")
+        end
+        count
+      end
+
+      def calculating_task_number
+        @calculating.inject(0) { |s, key_val| s + key_val[1].size }
+      end
+
+      # If queue is empty, that is, there is no tasks to calculate next,
+      # this method returns true. Otherwise, false.
+      # Even if there are calculating tasks,
+      # the method can return true.
+      def empty?
+        @cache.size - calculating_task_number == 0
+      end
+
+      # If there are no tasks in queue and calculating,
+      # return true. Otherwise, false.
+      def finished?
+        @cache.size == 0
+      end
+
+      def all_logs
+        @history.log_strings
+      end
+    end
+
+  end
+end

data/lib/drbqs/{server.rb → server/server.rb}

@@ -1,28 +1,12 @@
-require 'drbqs/message'
-require 'drbqs/queue'
-require 'drbqs/acl_file'
-require 'drbqs/server_hook'
+require 'drbqs/task/task'
+require 'drbqs/server/transfer_setting'
+require 'drbqs/server/check_alive'
+require 'drbqs/server/message'
+require 'drbqs/server/queue'
+require 'drbqs/server/acl_file'
+require 'drbqs/server/server_hook'
 
 module DRbQS
-  class CheckAlive
-    DEFAULT_INTERVAL_TIME = 300
-
-    def initialize(interval)
-      @interval = interval || DEFAULT_INTERVAL_TIME
-      if !(Numeric === @interval) || @interval < 0
-        raise ArgumentError, "Invalid interval time."
-      end
-      @last = Time.now
-    end
-
-    def significant_interval?
-      (Time.now - @last) >= @interval
-    end
-
-    def set_checking
-      @last = Time.now
-    end
-  end
 
   # When we set both empty_queue_hook and task_generator,
   # empty_queue_hook is prior to task_generator.
@@ -31,10 +15,13 @@ module DRbQS
     WAIT_TIME_NODE_FINALIZE = 10
     WAIT_TIME_NEW_RESULT = 1
 
-    attr_reader :queue
+    attr_reader :queue, :uri
 
     # :port
     #   Set the port of server.
+    # :unix
+    #   Set the path of unix domain socket.
+    #   If :port is specified, :port is preceded.
     # :acl
     #   Set the ACL instance.
     # :log_file
@@ -47,51 +34,45 @@ module DRbQS
     #   Exit programs in finish_hook.
     # :signal_trap
     #   Set trapping signal.
-    # :scp_user
-    #   Set user of scp.
-    # :scp_host
-    #   Set host of scp.
+    # :sftp_user
+    #   Set user of sftp.
+    # :sftp_host
+    #   Set host of sftp.
     # :file_directory
     #   Set the setting of file directory.
     def initialize(opts = {})
-      @port = opts[:port] || ROOT_DEFAULT_PORT
+      @uri = DRbQS::Misc.create_uri(opts)
       @acl = acl_init(opts[:acl])
+      @key = DRbQS::Misc.random_key + sprintf("_%d", Time.now.to_i)
       @ts = {
         :message => Rinda::TupleSpace.new,
         :queue => Rinda::TupleSpace.new,
         :result => Rinda::TupleSpace.new,
+        :key => @key,
         :transfer => nil
       }
-      @logger = DRbQS::Utils.create_logger(opts[:log_file], opts[:log_level])
-      @message = MessageServer.new(@ts[:message], @logger)
-      @queue= QueueServer.new(@ts[:queue], @ts[:result], @logger)
-      @check_alive = CheckAlive.new(opts[:check_alive])
+      @logger = DRbQS::Misc.create_logger(opts[:log_file], opts[:log_level])
+      @message = DRbQS::Server::Message.new(@ts[:message], @logger)
+      @queue= DRbQS::Server::Queue.new(@ts[:queue], @ts[:result], @logger)
+      @check_alive = DRbQS::Server::CheckAlive.new(opts[:check_alive])
       @task_generator = []
       hook_init(opts[:finish_exit])
       set_signal_trap if opts[:signal_trap]
       @finalization_task = nil
-      @transfer_setting = get_transfer_setting(opts[:scp_host], opts[:scp_user], opts[:file_directory])
+      @transfer_setting = DRbQS::Server::TransferSetting.new(opts[:sftp_host], opts[:sftp_user], opts[:file_directory])
+      @config = DRbQS::Config.new
     end
 
     def transfer_directory
       @ts[:transfer] && @ts[:transfer].directory
     end
 
-    def get_transfer_setting(host, user, directory)
-      setting = { :directory => directory, :user => user, :host => host, :set => true }
-      if host || user || directory
-        setting[:set] = true
-      end
-      setting
-    end
-    private :get_transfer_setting
-
     def acl_init(acl_arg)
       case acl_arg
       when Array
         ACL.new(acl_arg)
       when String
-        ACLFile.load(acl_arg)
+        DRbQS::Server::ACLFile.load(acl_arg)
       else
         nil
       end
@@ -99,24 +80,27 @@ module DRbQS
     private :acl_init
 
     def hook_init(finish_exit)
-      @hook = DRbQS::ServerHook.new
+      @hook = DRbQS::Server::Hook.new
       @hook.set_finish_exit { self.exit } if finish_exit
     end
     private :hook_init
 
+    def server_data
+      { :pid => Process.pid, :key => @key }
+    end
+    private :server_data
+
     def start
-      if @transfer_setting[:set] && @transfer_setting[:directory] && !@ts[:transfer]
-        set_file_transfer(@transfer_setting[:directory])
-      end
+      set_file_transfer(nil)
       DRb.install_acl(@acl) if @acl
-      uri = "druby://:#{@port}"
-      DRb.start_service(uri, @ts)
-      @logger.info("Start DRb service") { uri } if @logger
+      DRb.start_service(@uri, @ts)
+      @config.list.server.save(@uri, server_data)
+      @logger.info("Start DRb service") { @uri }
     end
 
     def check_connection(force = nil)
       if force || @check_alive.significant_interval?
-        @logger.info("Check connections.") if @logger
+        @logger.info("Check connections.")
         deleted_node_ids = @message.check_connection
         @queue.requeue_for_deleted_node_id(deleted_node_ids)
         @check_alive.set_checking
@@ -137,11 +121,12 @@ module DRbQS
       if @task_generator.size > 0 && @queue.empty?
         if tasks = @task_generator[0].new_tasks
           tasks.each { |t| @queue.add(t) }
-          @logger.info("Generator add #{tasks.size} tasks.") if @logger
+          @logger.info("Generator add #{tasks.size} tasks.")
         else
           @task_generator.delete_at(0)
-          @logger.info("Generator creates all tasks and then has been deleted.") if @logger
+          @logger.info("Generator creates all tasks and then has been deleted.")
           if @task_generator.size > 0
+            first_task_generator_init
             add_tasks_from_generator
           end
         end
@@ -155,6 +140,7 @@ module DRbQS
 
     def set_finalization_task(task)
       @finalization_task = task
+      @message.set_finalization(@finalization_task)
     end
 
     # +key+ is :empty_queue or :finish_exit.
@@ -168,14 +154,14 @@ module DRbQS
     end
 
     def exec_finish_hook
-      @logger.info("Execute finish hook.") if @logger
+      @logger.info("Execute finish hook.")
       @hook.exec(:finish, self)
     end
     private :exec_finish_hook
     
     def exec_hook
       if @queue.empty?
-        @logger.info("Execute empty queue hook.") if @logger
+        @logger.info("Execute empty queue hook.")
         @hook.exec(:empty_queue, self)
       end
       if !generator_waiting? || @queue.finished?
@@ -189,7 +175,7 @@ module DRbQS
 
     def exit
       if @finalization_task
-        @message.send_finalization(@finalization_task)
+        @message.send_finalization
         wait_time = WAIT_TIME_NODE_FINALIZE
       else
         @message.send_exit
@@ -199,7 +185,8 @@ module DRbQS
         sleep(wait_time)
         check_connection(true)
       end
-      @logger.info("History of tasks") { "\n" + @queue.all_logs } if @logger
+      @logger.info("History of tasks") { "\n" + @queue.all_logs }
+      @config.list.server.delete(@uri)
       Kernel.exit
     end
 
@@ -210,10 +197,10 @@ module DRbQS
     end
 
     def set_file_transfer(directory, opts = {})
-      user = opts[:user] || @transfer_setting[:user] || ENV['USER']
-      host = opts[:host] || @transfer_setting[:host] || 'localhost'
-      @ts[:transfer] = DRbQS::Transfer.new(user, host, directory)
-      @logger.info("File transfer") { @ts[:transfer].information } if @logger
+      if transfer = @transfer_setting.create(directory, opts)
+        @ts[:transfer] = transfer
+        @logger.info("File transfer") { transfer.information }
+      end
     end
 
     def check_message
@@ -224,6 +211,11 @@ module DRbQS
           self.exit
         when :request_status
           @message.send_status(@queue.calculating)
+        when :exit_after_task
+          node_id = arg
+          if @message.node_exist?(node_id)
+            @message.send_exit_after_task(node_id)
+          end
         when :node_error
           @queue.get_accept_signal
           @queue.requeue_for_deleted_node_id([arg])
@@ -232,19 +224,19 @@ module DRbQS
     end
     private :check_message
 
-    def task_generator_init
-      @task_generator.each { |tgen| tgen.init }
+    def first_task_generator_init
+      @task_generator[0].init if @task_generator[0]
     end
-    private :task_generator_init
+    private :first_task_generator_init
 
     def wait
-      task_generator_init
+      first_task_generator_init
       loop do
         check_message
         check_connection
         count_results = @queue.get_result(self)
         exec_hook
-        @logger.debug("Calculating tasks: #{@queue.calculating_task_number}") if @logger
+        @logger.debug("Calculating tasks: #{@queue.calculating_task_number}")
         if count_results <= 1
           sleep(WAIT_TIME_NEW_RESULT)
         end
@@ -267,11 +259,11 @@ module DRbQS
     private :finish_profile
 
     def test_exec(opts = {})
-      task_generator_init
-      dummy_client = DRbQS::Client.new(nil, :log_file => $stdout, :log_level => opts[:log_level])
-      dummy_task_client = DRbQS::TaskClient.new(nil, @ts[:queue], nil)
+      first_task_generator_init
+      dummy_node = DRbQS::Node.new(nil, :log_file => $stdout, :log_level => opts[:log_level])
+      dummy_task_client = DRbQS::Node::TaskClient.new(nil, @ts[:queue], nil)
       if @ts[:transfer]
-        dummy_client.instance_variable_set(:@transfer, DRbQS::TransferTest.new(@ts[:transfer].directory))
+        dummy_node.instance_variable_set(:@transfer, DRbQS::TransferClient::Local.new(@ts[:transfer].directory))
       end
       num = 0
       start_profile if opts[:profile]
@@ -279,7 +271,7 @@ module DRbQS
         exec_hook
         if ary = dummy_task_client.get_task
           task_id, marshal_obj, method_sym, args = ary
-          result = dummy_client.instance_eval { execute_task(marshal_obj, method_sym, args) }
+          result = dummy_node.instance_eval { execute_task(marshal_obj, method_sym, args) }
           @queue.exec_task_hook(self, task_id, result)
         end
         num += 1
@@ -290,15 +282,15 @@ module DRbQS
       finish_profile if opts[:profile]
       if @finalization_task
         args = @finalization_task.drb_args(nil)[1..-1]
-        dummy_client.instance_eval { execute_task(*args) }
+        dummy_node.instance_eval { execute_task(*args) }
       end
       exec_finish_hook
     end
 
     def test_task_generator(opts = {})
-      task_generator_init
       @task_generator.each_with_index do |t, i|
         puts "Test task generator [#{i}]"
+        t.init
         set_num, task_num = t.debug_all_tasks(opts)
         puts "Create: task sets #{set_num}, all tasks #{task_num}"
       end

data/lib/drbqs/server/server_hook.rb

@@ -0,0 +1,72 @@
+module DRbQS
+  class Server
+    class Hook
+      def initialize
+        @hook = Hash.new { |h, k| h[k] = Array.new }
+        @argument_number = {}
+        @finish_exit = nil
+        set_argument_number(:empty_queue, 1)
+        set_argument_number(:finish, 1)
+      end
+
+      def set_argument_number(key, num)
+        @argument_number[key] = num
+      end
+      private :set_argument_number
+
+      def create_proc_name(key)
+        name = "#{key.to_s}#{rand(1000)}"
+        if @hook.has_key?(name)
+          create_proc_name(key)
+        else
+          name
+        end
+      end
+      private :create_proc_name
+
+      def add(key, name = nil, &block)
+        if (n = @argument_number[key]) && (block.arity != n)
+          raise ArgumentError, "Invalid argument number of hook of #{key.inspect}."
+        end
+        name ||= create_proc_name(key)
+        @hook[key] << [name, block]
+        name
+      end
+
+      def delete(key, name = nil)
+        if name
+          @hook[key].delete_if { |ary| ary[0] == name }
+        else
+          @hook[key].clear
+        end
+      end
+
+      def specific_proc(key)
+        case key
+        when :finish
+          @finish_exit.call if @finish_exit
+        end
+      end
+      private :specific_proc
+
+      def hook_names(key)
+        @hook[key].map { |a| a[0] }
+      end
+
+      def exec(key, *args)
+        @hook[key].each do |ary|
+          ary[1].call(*args)
+        end
+        specific_proc(key)
+      end
+
+      def set_finish_exit(&block)
+        @finish_exit = block
+      end
+
+      def number_of_hook(key)
+        @hook[key].size
+      end
+    end
+  end
+end