drbqs 0.0.13 → 0.0.14

data/lib/drbqs/manage/manage.rb

@@ -0,0 +1,100 @@
+require 'drbqs/manage/ssh_execute'
+require 'drbqs/manage/send_signal'
+
+module DRbQS
+  class Manage
+    class NotSetURI < StandardError
+    end
+
+    WAIT_SERVER_TIME = 0.3
+    WAIT_MAX_NUMBER = 200
+
+    # +opts+ has keys :home and :uri.
+    def initialize(opts = {})
+      @opts = opts
+      @config = nil
+      @signal_sender = nil
+    end
+
+    def set_uri(uri)
+      @opts[:uri] = uri
+    end
+
+    def set_home_directory(dir)
+      @opts[:home] = dir
+    end
+
+    def config
+      unless @config
+        if @opts[:home]
+          DRbQS::Config.set_home_directory(@opts[:home])
+        end
+        @config = DRbQS::Config.new
+      end
+      @config
+    end
+    private :config
+
+    def signal_sender
+      unless @signal_sender
+        unless @opts[:uri]
+          raise DRbQS::Manage::NotSetURI, "The uri has not set yet."
+        end
+        obj = DRbObject.new_with_uri(@opts[:uri])
+        @signal_sender = DRbQS::Manage::SendSignal.new(obj[:message])
+      end
+      @signal_sender
+    end
+    private :signal_sender
+
+    def create_config
+      config.save_sample
+    end
+
+    def send_exit_signal
+      signal_sender.send_exit_signal
+    end
+
+    def send_node_exit_after_task(node_id)
+      signal_sender.send_node_exit_after_task(node_id)
+    end
+
+    def get_status
+      signal_sender.get_status
+    end
+
+    def server_respond?
+      begin
+        get_status
+        true
+      rescue DRbQS::Manage::NotSetURI
+        raise
+      rescue
+        nil
+      end
+    end
+
+    def wait_server_process(pid)
+      i = 0
+      begin
+        sleep(WAIT_SERVER_TIME)
+        unless DRbQS::Misc.process_running_normally?(pid)
+          return nil
+        end
+        i += 1
+        if i > WAIT_MAX_NUMBER
+          raise "Can not wait server process."
+        end
+      end while !server_respond?
+      true
+    end
+
+    def list_process
+      { :server => config.list.server.list, :node => config.list.node.list }
+    end
+
+    def clear_process
+      config.list.clear_process_not_exist
+    end
+  end
+end

data/lib/drbqs/manage/send_signal.rb

@@ -0,0 +1,45 @@
+module DRbQS
+  class Manage
+    class SendSignal
+      MAX_WAIT_TIME = 10
+
+      def initialize(message)
+        @message = message
+      end
+
+      def sender_id
+        "#{Socket.gethostname}/#{Process.pid}"
+      end
+
+      def send_signal_to_server(signal, arg)
+        @message.write([:server, signal, arg])
+      end
+      private :send_signal_to_server
+
+      def send_exit_signal
+        send_signal_to_server(:exit_server, sender_id)
+      end
+
+      def send_node_exit_after_task(node_id)
+        send_signal_to_server(:exit_after_task, node_id)
+      end
+
+      def get_status
+        send_signal_to_server(:request_status, sender_id)
+        i = 0
+        loop do
+          begin
+            mes = @message.take([:status, String], 0)
+            return mes[1]
+          rescue Rinda::RequestExpiredError
+            i += 1
+            if i > MAX_WAIT_TIME
+              return nil
+            end
+            sleep(1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/drbqs/manage/ssh_execute.rb

@@ -0,0 +1,23 @@
+require 'drbqs/manage/ssh_shell'
+
+module DRbQS
+  class Manage
+    class SSHExecute
+      def initialize(dest, opts = {})
+        @ssh_host = DRbQS::Config.new.ssh_host
+        path, options = @ssh_host.get_options(dest)
+        # $stdout.puts "Use configuration: #{path}" if path
+        dest = options[:dest] || dest
+        @ssh = DRbQS::Manage::SSHShell.new(dest, options.merge(opts))
+      end
+
+      def execute(command)
+        @ssh.start(command)
+      end
+
+      def get_environment
+        @ssh.get_environment
+      end
+    end
+  end
+end

data/lib/drbqs/manage/ssh_shell.rb

@@ -0,0 +1,143 @@
+require 'net/ssh'
+require 'net/ssh/shell'
+
+module DRbQS
+
+  class Manage
+    # Requirements:
+    #   bash
+    #   nohup
+    class SSHShell
+      class InvalidDestination < StandardError
+      end
+      class GetInvalidExitStatus < StandardError
+      end
+
+      attr_reader :user, :host, :directory, :port
+
+      DEFAULT_RVM_SCRIPT = '$HOME/.rvm/scripts/rvm'
+      DEFAULT_OUTPUT_FILE = 'drbqs_nohup.log'
+
+      # :shell     shell to use
+      # :dir       base directory of ssh server
+      # :rvm       version of ruby on rvm
+      # :rvm_init  path of script to initialize rvm
+      # :output    file to output of stdout and stderr
+      def initialize(dest, opts = {})
+        @user, @host, @port = split_destination(dest)
+        if !(@host && @user)
+          raise InvalidDestination, "Invalid destination of ssh server."
+        end
+        @shell = opts[:shell] || 'bash'
+        @rvm = opts[:rvm]
+        @rvm_init = opts[:rvm_init]
+        if (@rvm || @rvm_init) && !(String === @rvm_init)
+          @rvm_init = DEFAULT_RVM_SCRIPT
+        end
+        @nohup_output = opts[:output] || DEFAULT_OUTPUT_FILE
+        @directory = opts[:dir]
+        @out = $stdout
+        @nice = opts[:nice]
+        @nohup = opts[:nohup]
+      end
+
+      def split_destination(dest)
+        if (n = dest.index("@")) && n > 0
+          user = dest[0..(n - 1)]
+          host_dir = dest[(n + 1)..-1]
+        else
+          raise "Not include '@': #{dest}"
+        end
+        if n = host_dir.index(':')
+          host = host_dir[0..(n - 1)]
+          port = host_dir[(n + 1)..-1]
+        else
+          host = host_dir
+          port = nil
+        end
+        [user && user.size > 0 ? user : nil,
+         host && host.size > 0 ? host : nil,
+         port && port.size > 0 ? port.to_i : nil]
+      end
+      private :split_destination
+
+      def output_command(cmd, result)
+        @out.puts "#{@user}@#{@host}$ #{cmd}" if @out
+        @out.print result
+      end
+      private :output_command
+
+      def shell_exec_get_output(sh, cmd)
+        result = ''
+        pr_cmd = sh.execute!(cmd) do |sh_proc|
+          sh_proc.on_output do |pr, data|
+            result << data
+          end
+          sh_proc.on_error_output do |pr, data|
+            result << data
+          end
+        end
+        [pr_cmd, result]
+      end
+      private :shell_exec_get_output
+
+      def shell_exec(sh, cmd)
+        ary = shell_exec_get_output(sh, cmd)
+        output_command(cmd, ary[1])
+        ary
+      end
+      private :shell_exec
+
+      def shell_exec_check(sh, cmd)
+        ary = shell_exec(sh, cmd)
+        if ary[0].exit_status != 0
+          raise GetInvalidExitStatus, "Can not execute '#{cmd}' on #{@host} properly."
+        end
+        ary
+      end
+      private :shell_exec_check
+
+      def execute_command(&block)
+        Net::SSH.start(@host, @user, :port => @port) do |ssh|
+          ssh.shell(@shell) do |sh|
+            shell_exec_check(sh, "cd #{@directory}") if @directory
+            shell_exec_check(sh, "source #{@rvm_init}") if @rvm_init
+            shell_exec_check(sh, "rvm use #{@rvm}") if @rvm
+            yield(sh)
+            shell_exec(sh, "exit")
+          end
+        end
+      end
+      private :execute_command
+
+      def get_environment
+        execute_command do |sh|
+          ['echo "directory: " `pwd`',
+           'echo "files:"',
+           'ls',
+           'if which rvm > /dev/null; then rvm info; else ruby -v; fi'].each do |cmd|
+            shell_exec(sh, cmd)
+          end
+        end
+      end
+
+      def start(*args)
+        cmd = args.join(' ')
+        if @nice
+          if Integer === @nice
+            cmd = "nice -n #{@nice.to_s} " + cmd
+          else
+            cmd = "nice " + cmd
+          end
+        end
+        execute_command do |sh|
+          if @nohup
+            pr, path = shell_exec_check(sh, "filename-create new -p middle -D parent -t time #{@nohup_output}")
+            cmd = "nohup #{cmd} > #{path.strip} 2>&1 &"
+          end
+          shell_exec(sh, cmd)
+        end
+      end
+    end
+  end
+end

data/lib/drbqs/node/connection.rb

@@ -0,0 +1,69 @@
+module DRbQS
+  class Node
+    # The class of connection to server.
+    class Connection
+      attr_reader :id, :node_number
+
+      def initialize(message, logger = DRbQS::LoggerDummy.new)
+        @message = message
+        @logger = logger
+        @node_number = nil
+        @id = create_id_string
+      end
+
+      def create_id_string
+        t = Time.now
+        sprintf("#{Socket.gethostname}:%d", Process.pid)
+      end
+      private :create_id_string
+
+      def node_number
+        unless @node_number
+          @message.write([:server, :connect, @id])
+          @node_number = @message.take([@id, Fixnum])[1]
+          @logger.info("Get node id: #{@node_number}")
+        end
+        @node_number
+      end
+
+      def get_special_task(label)
+        begin
+          ary = @message.read([label, nil, Symbol, nil], 0)
+          ary[1..-1]
+        rescue Rinda::RequestExpiredError
+          nil
+        end
+      end
+      private :get_special_task
+
+      def get_initialization
+        get_special_task(:initialize)
+      end
+
+      def get_finalization
+        get_special_task(:finalize)
+      end
+
+      def respond_signal
+        begin
+          node_id, sym = @message.take([@node_number, Symbol], 0)
+          @logger.info("Get signal: #{sym.inspect}")
+          case sym
+          when :alive_p
+            @message.write([:server, :alive, @node_number])
+            @logger.info("Send alive signal of node id #{@node_number}")
+          when :exit, :finalize, :exit_after_task
+            return sym
+          else
+            raise "Get invalid signal: #{sym.inspect}"
+          end
+        rescue Rinda::RequestExpiredError
+        end
+      end
+
+      def send_node_error(error_message)
+        @message.write([:server, :node_error, [@node_number, error_message]])
+      end
+    end
+  end
+end

data/lib/drbqs/{client.rb → node/node.rb}

@@ -1,9 +1,12 @@
-require 'drbqs/connection'
-require 'drbqs/task_client'
+require 'drbqs/task/task'
+require 'drbqs/utility/transfer/transfer_client'
+require 'drbqs/node/connection'
+require 'drbqs/node/task_client'
+require 'drbqs/utility/temporary'
 
 module DRbQS
 
-  class Client
+  class Node
 
     WAIT_NEW_TASK = 1
     PRIORITY_RESPOND = 10
@@ -14,18 +17,27 @@ module DRbQS
     # :continue
     def initialize(access_uri, opts = {})
       @access_uri = access_uri
-      @logger = DRbQS::Utils.create_logger(opts[:log_file] || DEFAULT_LOG_FILE, opts[:log_level])
+      @logger = DRbQS::Misc.create_logger(opts[:log_file] || DEFAULT_LOG_FILE, opts[:log_level])
       @connection = nil
       @task_client = nil
       @process_continue = opts[:continue]
       @signal_queue = Queue.new
+      @config = DRbQS::Config.new
     end
 
     def transfer_file
-      until FileTransfer.empty?
-        path = FileTransfer.dequeue
-        unless @transfer.scp(path)
-          raise "Can not send file: #{path}"
+      if files = DRbQS::FileTransfer.dequeue_all
+        if @transfer
+          begin
+            @transfer.transfer(files, server_on_same_host?)
+          rescue => err
+            @logger.error("Fail to transfer files.") do
+              "Can not send file: #{files.join(", ")}\n#{err.to_s}\n#{err.backtrace.join("\n")}"
+            end
+            raise
+          end
+        else
+          raise "Server does not set transfer settings. Can not send file: #{files.join(", ")}"
         end
       end
     end
@@ -34,19 +46,30 @@ module DRbQS
     def execute_task(marshal_obj, method_sym, args)
       result = DRbQS::Task.execute_task(marshal_obj, method_sym, args)
       transfer_file
+      DRbQS::Temporary.delete
       result
     end
     private :execute_task
 
+    def node_data
+      { :uri => @access_uri }
+    end
+    private :node_data
+
     def connect
       obj = DRbObject.new_with_uri(@access_uri)
-      @connection = ConnectionClient.new(obj[:message], @logger)
-      node_id = @connection.get_id
-      @task_client = TaskClient.new(node_id, obj[:queue], obj[:result], @logger)
+      @server_key = obj[:key]
+      @connection = Node::Connection.new(obj[:message], @logger)
+      @task_client = Node::TaskClient.new(@connection.node_number, obj[:queue], obj[:result], @logger)
       @transfer = obj[:transfer]
       if ary = @connection.get_initialization
         execute_task(*ary)
       end
+      @config.list.node.save(Process.pid, node_data)
+    end
+
+    def server_on_same_host?
+      @config.list.server.server_of_key_exist?(@access_uri, @server_key)
     end
 
     def dump_not_send_result_to_file
@@ -58,9 +81,7 @@ module DRbQS
     private :dump_not_send_result_to_file
 
     def output_error(err, mes)
-      if @logger
-        @logger.error("#{mes}: #{err.to_s}") { "\n" + err.backtrace.join("\n") }
-      end
+      @logger.error("#{mes}: #{err.to_s}") { "\n" + err.backtrace.join("\n") }
     end
     private :output_error
 
@@ -88,15 +109,18 @@ module DRbQS
     private :send_error
 
     def communicate_with_server
+      flag_finilize_exit = false
       @task_client.add_new_task
       case @connection.respond_signal
       when :exit
         return nil
       when :finalize
-        execute_finalization
-        return nil
+        flag_finilize_exit = true
+      when :exit_after_task
+        @task_client.set_exit_after_task
+        @process_continue = nil
       end
-      @task_client.send_result
+      flag_finilize_exit = @task_client.send_result
       until @signal_queue.empty?
         signal, obj = @signal_queue.pop
         case signal
@@ -105,7 +129,11 @@ module DRbQS
           process_exit
         end
       end
-      return true
+      if flag_finilize_exit
+        execute_finalization
+        return nil
+      end
+      true
     end
     private :communicate_with_server
 
@@ -120,6 +148,8 @@ module DRbQS
         begin
           loop do
             unless communicate_with_server
+              DRbQS::Temporary.delete_all
+              @config.list.node.delete(Process.pid)
               break
             end
             sleep(WAIT_NEW_TASK)

data/lib/drbqs/node/task_client.rb

@@ -0,0 +1,94 @@
+module DRbQS
+  class Node
+    class TaskClient
+      attr_reader :node_number, :calculating_task
+
+      def initialize(node_number, queue, result, logger = DRbQS::LoggerDummy.new)
+        @node_number = node_number
+        @queue = queue
+        @result = result
+        @calculating_task = nil
+        @exit_after_task = nil
+        @task_queue = Queue.new
+        @result_queue = Queue.new
+        @logger = logger
+      end
+
+      def calculating?
+        !!@calculating_task
+      end
+
+      def task_empty?
+        @task_queue.empty?
+      end
+
+      def result_empty?
+        @result_queue.empty?
+      end
+
+      def dequeue_result
+        @result_queue.deq
+      end
+      private :dequeue_result
+
+      def queue_task(task_id, ary)
+        @calculating_task = task_id
+        @task_queue.enq(ary)
+      end
+
+      def dequeue_task
+        @task_queue.deq
+      end
+
+      def get_task
+        begin
+          @queue.take([Fixnum, nil, Symbol, nil], 0)
+        rescue Rinda::RequestExpiredError
+          nil
+        end
+      end
+
+      def set_exit_after_task
+        @exit_after_task = true
+      end
+
+      def add_new_task
+        if !@calculating_task && !@exit_after_task
+          if ary = get_task
+            task_id, obj, method_sym, args = ary
+            @logger.info("Send accept signal: node #{@node_number} caluclating #{task_id}")
+            @result.write([:accept, task_id, @node_number])
+            queue_task(task_id, [obj, method_sym, args])
+          end
+        end
+      end
+
+      # If the method return true, a node should finilize and exit.
+      def send_result
+        if !result_empty?
+          result = dequeue_result
+          @logger.info("Send result: #{@calculating_task}") { result.inspect }
+          @result.write([:result, @calculating_task, @node_number, result])
+          @calculating_task = nil
+        end
+        !@calculating_task && @exit_after_task
+      end
+
+      def queue_result(result)
+        @result_queue.enq(result)
+      end
+
+      def dump_result_queue
+        results = []
+        while !result_empty?
+          results << dequeue_result
+        end
+        if results.size > 0
+          Marshal.dump(results)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/drbqs/server/acl_file.rb

@@ -0,0 +1,15 @@
+module DRbQS
+  class Server
+    module ACLFile
+
+      # Create ACL object from file.
+      # The example of file is the following:
+      # deny all
+      # allow localhost
+      # allow 127.0.0.1
+      def self.load(path)
+        ACL.new(File.read(path).split)
+      end
+    end
+  end
+end

data/lib/drbqs/server/check_alive.rb

@@ -0,0 +1,23 @@
+module DRbQS
+  class Server
+    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
+  end
+end

data/lib/drbqs/server/history.rb

@@ -0,0 +1,49 @@
+module DRbQS
+  class Server
+
+    # This class is used in DRbQS::Server::NodeList and DRbQS::Server::Queue to save some histories.
+    class History
+      include DRbQS::Misc
+
+      def initialize
+        @data = Hash.new { |h, k| h[k] = Array.new }
+      end
+
+      def set(id, *args)
+        @data[id] << args.unshift(Time.now)
+      end
+
+      def size
+        @data.size
+      end
+
+      def events(id)
+        @data[id]
+      end
+
+      def number_of_events(id)
+        @data[id].size
+      end
+
+      def each(&block)
+        @data.each(&block)
+      end
+
+      def log_strings
+        s = ''
+        each do |task_id, events|
+          s << "Task #{task_id}\n"
+          events.each do |ev|
+            case ev[1]
+            when :add, :requeue, :hook
+              s << "  #{time_to_history_string(ev[0])}\t#{ev[1]}\n"
+            when :calculate, :result
+              s << "  #{time_to_history_string(ev[0])}\t#{ev[1]} (node #{ev[2]})\n"
+            end
+          end
+        end
+        s
+      end
+    end
+  end
+end