drbqs 0.0.14 → 0.0.15

data/lib/drbqs/setting/data_container.rb

@@ -0,0 +1,39 @@
+module DRbQS
+  class Setting
+    class Source
+      class DataContainer < BasicObject
+        attr_accessor :argument
+        attr_reader :__data__
+
+        def initialize(array_class)
+          @argument = []
+          @__data__ = {}
+          @__array__ = array_class
+        end
+
+        def method_missing(name, *args)
+          if args.size > 0
+            s = name.to_s
+            key = (/=$/ =~ s ? s[0...-1].intern : name.intern)
+            @__data__[key] = (@__array__ === args[0] ? args[0] : args)
+          else
+            @__data__[name]
+          end
+        end
+
+        def __delete__(name)
+          @__data__.delete(name.intern)
+        end
+      end
+
+      def self.clone_container(obj)
+        cl = DRbQS::Setting::Source::DataContainer.new(Array)
+        cl.argument = obj.argument.clone
+        obj.__data__.each do |key, val|
+          cl.__data__[key] = val
+        end
+        cl
+      end
+    end
+  end
+end

data/lib/drbqs/setting/execute.rb

@@ -0,0 +1,71 @@
+require 'drbqs/execute/process_define'
+
+module DRbQS
+  class Setting
+    class Execute < DRbQS::Setting::Base
+      attr_accessor :server_argument
+
+      def initialize
+        super(:all_keys_defined => true) do
+          [:port, :server, :node].each do |key|
+            register_key(key, :check => 1)
+          end
+          [:no_server, :no_node, :information, :help].each do |key|
+            register_key(key, :bool => true)
+          end
+          set_argument_condition(:<=, 1)
+        end
+        @server_argument = []
+      end
+
+      # If there are invalid arguments,
+      # this method raises an error.
+      def parse!
+        super
+        @port = get_first(:port) do |val|
+          val.to_i
+        end
+        @no_server = get_first(:no_server)
+        @server = get_first(:server) do |val|
+          val.intern
+        end
+        @no_node = get_first(:no_node)
+        @node = get_first(:node) do |val|
+          val.split(',').map do |s|
+            s.intern
+          end
+        end
+        @definition = get_argument[0]
+        if get_first(:help)
+          @mode = :help
+        elsif get_first(:information)
+          @mode = :information
+        else
+          @mode = nil
+        end
+        if !@output_help && !@definition
+          raise DRbQS::Setting::InvalidArgument, "Definition file must be specified."
+        end
+      end
+
+      def exec(io = nil)
+        process_def = DRbQS::ProcessDefinition.new(@server, @node, @port, io)
+        process_def.load(@definition) if @definition
+        case @mode
+        when :help
+          io.puts process_def.usage if io
+        when :information
+          io.puts process_def.information_string if io
+        else
+          unless @no_server
+            process_def.execute_server(@server_argument)
+          end
+          unless @no_node
+            process_def.execute_node
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/drbqs/setting/manage.rb

@@ -0,0 +1,163 @@
+module DRbQS
+  class Setting
+    class Manage < DRbQS::Setting::Base
+      include DRbQS::Command::Argument
+
+      def initialize
+        super(:all_keys_defined => true) do
+          set_argument_condition(:>, 0)
+        end
+      end
+
+      def check_all_arguments
+        case @mode
+        when 'initialize'
+          check_argument_size(@argv, :>=, 0, :<=, 1)
+        when 'process'
+          check_argument_size(@argv, :>=, 0, :<=, 1)
+          if @argv[0] && !['clear', 'list'].include?(@argv[0])
+            raise DRbQS::Setting::InvalidArgument, "Invalid command 'process #{@argv[0]}'"
+          end
+        when 'status', 'history'
+          check_argument_size(@argv, :==, 1)
+        when 'signal'
+          case @argv[1]
+          when 'server-exit'
+            check_argument_size(@argv, :==, 2)
+          when 'node-exit-after-task', 'node-wake', 'node-sleep'
+            check_argument_size(@argv, :==, 3)
+          else
+            raise DRbQS::Setting::InvalidArgument, "Invalid signal type '#{@argv[1]}'"
+          end
+        when 'send'
+          check_argument_size(@argv, :==, 3)
+          case @argv[0]
+          when 'string'
+            unless @argv[2]
+              raise DRbQS::Setting::InvalidArgument, "String data is not set"
+            end
+          when 'file'
+            unless File.exist?(@argv[2])
+              raise DRbQS::Setting::InvalidArgument, "File '#{@argv[2]}' does not exist"
+            end
+          else
+            raise DRbQS::Setting::InvalidArgument, "Invalid option '#{argv[2]}' for 'send'"
+          end
+        else
+          raise DRbQS::Setting::InvalidArgument, "Invalid command '#{@mode}'"
+        end
+      end
+      private :check_all_arguments
+
+      # If there are invalid arguments,
+      # this method raises an error.
+      def parse!
+        super
+        ary = get_argument
+        @mode = ary[0].to_s
+        @argv = ary[1..-1]
+        check_all_arguments
+      end
+
+      def command_initialize
+        @manage.set_home_directory(@argv[0])
+        @manage.create_config
+      end
+      private :command_initialize
+
+      def command_process(io)
+        if @argv[0] == 'clear'
+          @manage.clear_process
+          return true
+        end
+        result = ''
+        list = @manage.list_process
+        result << "Server\n"
+        list[:server].each do |uri, data|
+          result << "#{uri}\n"
+          data.each do |k, v|
+            result << sprintf("  %-10s  %s\n", k, v)
+          end
+        end
+        result << "\nNode\n"
+        list[:node].each do |pid, data|
+          result << "#{pid}\n"
+          data.each do |k, v|
+            result << sprintf("  %-10s  %s\n", k, v)
+          end
+        end
+        io.print result if io
+      end
+      private :command_process
+
+      def request_to_server(io, method_name)
+        @manage.set_uri(@argv[0])
+        if status = @manage.__send__(method_name)
+          io.puts status if io
+        end
+      end
+      private :request_to_server
+
+      def command_status(io)
+        request_to_server(io, :get_status)
+      end
+      private :command_status
+
+      def command_history
+        request_to_server(io, :get_history)
+      end
+      private :command_history
+
+      def signal_to_node(method_name)
+        node_id = @argv[2].to_i
+        @manage.__send__(method_name, node_id)
+      end
+      private :signal_to_node
+
+      def command_signal
+        @manage.set_uri(@argv[0])
+        case @argv[1]
+        when 'server-exit'
+          @manage.send_exit_signal
+        when 'node-exit-after-task'
+          signal_to_node(:send_node_exit_after_task)
+        when 'node-wake'
+          signal_to_node(:send_node_wake)
+        when 'node-sleep'
+          signal_to_node(:send_node_sleep)
+        end
+      end
+      private :command_signal
+
+      def command_send
+        @manage.set_uri(@argv[1])
+        case @argv[0]
+        when 'string'
+          data = @argv[2]
+        when 'file'
+          data = File.read(@argv[2])
+        end
+        @manage.send_data(data)
+      end
+      private :command_send
+
+      def exec(io = nil)
+        @manage = DRbQS::Manage.new
+        case @mode
+        when 'initialize'
+          command_initialize
+        when 'process'
+          command_process(io)
+        when 'status'
+          command_status(io)
+        when 'history'
+          command_history(io)
+        when 'signal'
+          command_signal
+        when 'send'
+          command_send
+        end
+      end
+    end
+  end
+end

data/lib/drbqs/setting/node.rb

@@ -0,0 +1,84 @@
+module DRbQS
+  class Setting
+    class Node < DRbQS::Setting::Base
+      LOG_PREFIX_DEFAULT = 'drbqs_node'
+
+      def initialize
+        super(:all_keys_defined => true, :log_level => true, :daemon => true) do
+          register_key(:load, :check => [:>, 0], :add => true)
+          register_key(:process, :check => 1, :default => [1])
+          register_key(:loadavg, :check => 1)
+          register_key(:log_prefix, :check => 1, :default => [LOG_PREFIX_DEFAULT])
+          register_key(:log_stdout, :bool => true)
+          register_key(:connect, :check => 1)
+          set_argument_condition(:==, 1)
+        end
+      end
+
+      def preprocess!
+        if connect = get_first(:connect)
+          value.argument.unshift(connect)
+          clear(:connect)
+        end
+      end
+      private :preprocess!
+
+      # If there are invalid arguments,
+      # this method raises an error.
+      def parse!
+        super
+        parse_load
+        parse_loadavg
+        if !get(:log_stdout)
+          @options[:log_prefix] = get_first(:log_prefix) do |val|
+            str = val.to_s
+            str += 'out' if /\/$/ =~ str
+            str
+          end
+        end
+        @process_num = get_first(:process)
+        @uri = get_argument[0]
+      end
+
+      def parse_load
+        @options[:load] = []
+        get(:load).to_a.each do |path|
+          @options[:load] << File.expand_path(path)
+        end
+      end
+      private :parse_load
+
+      def parse_loadavg
+        @options[:node_opts] = {}
+        if args = get(:loadavg)
+          max_loadavg, sleep_time = args[0].split(':', -1)
+          @options[:node_opts][:max_loadavg] = max_loadavg && max_loadavg.size > 0 ? max_loadavg.to_f : nil
+          @options[:node_opts][:sleep_time] = sleep_time && sleep_time.size > 0 ? sleep_time.to_i : nil
+        end
+      end
+      private :parse_loadavg
+
+      def exec(io = nil)
+        return true if exec_as_daemon
+
+        @options[:load].each do |path|
+          io.puts "load #{path}" if io
+          unless File.exist?(path)
+            raise DRbQS::Setting::InvalidArgument, "#{path} does not exist."
+          end
+          load path
+        end
+
+        if io
+          io.puts "Connect to #{@uri}"
+          io.puts "Execute #{@process_num} processes"
+        end
+
+        exec_node = DRbQS::ExecuteNode.new(@uri, @options[:log_prefix], @options[:log_level], @options[:node_opts])
+        exec_node.execute(@process_num)
+        exec_node.wait
+        true
+      end
+    end
+  end
+end

data/lib/drbqs/setting/server.rb

@@ -0,0 +1,230 @@
+module DRbQS
+  class Setting
+    class Server < DRbQS::Setting::Base
+      include DRbQS::Misc
+
+      NODE_INTERVAL_TIME = 1
+
+      def initialize
+        super(:all_keys_defined => true, :log_level => true, :daemon => true) do
+          [:port, :unix, :acl, :sftp_user, :sftp_host,
+           :profile_printer, :test, :execute_node].each do |key|
+            register_key(key, :check => 1)
+          end
+          register_key(:log_file, :check => 1, :default => [STDOUT])
+          register_key(:profile, :bool => true)
+          register_key(:load, :add => true)
+          register_key(:help, :bool => true)
+          set_argument_condition(:>, 0)
+        end
+        @server_argument = DRbQS::Setting::Source.new(nil)
+        @command_type = :server_start
+        @test_opts = {}
+        @execute_node_number = nil
+      end
+
+      def parse_test
+        @test_opts[:profile] = get(:profile)
+        @test_opts[:printer] = get_first(:printer) do |val|
+          val.intern
+        end
+        if test = get_first(:test)
+          @command_type = "test_#{test.to_s}"
+        end
+      end
+      private :parse_test
+
+      def parse_execute_node
+        @execute_node_number = get_first(:execute_node) do |val|
+          val.to_i
+        end
+      end
+      private :parse_execute_node
+
+      def preprocess!
+        if files = get(:load)
+          value.argument.concat(files)
+          clear(:load)
+        end
+      end
+      private :preprocess!
+
+      def parse!
+        if get(:help)
+          @command_type = :help
+          return true
+        end
+        super
+        parse_test
+        parse_execute_node
+        @options[:port] = get_first(:port) do |val|
+          val.to_i
+        end
+        @options[:unix] = get_first(:unix)
+        @options[:acl] = get_first(:acl)
+        @options[:sftp_user] = get_first(:sftp_user)
+        @options[:sftp_host] = get_first(:sftp_host)
+        @options[:log_file] = get_first(:log_file)
+        @options.delete_if do |key, val|
+          !val
+        end
+      end
+
+      def set_server_argument(*args)
+        @server_argument.set_argument(*args)
+      end
+
+      def command_line_argument(escape = nil)
+        ary = super(escape)
+        server_args = @server_argument.command_line_argument(escape)
+        if server_args.size > 0
+          ary << '--'
+          ary.concat(server_args)
+        end
+        ary
+      end
+
+      def command_test(io)
+        args = @command_type.split('_')[1].split(',')
+        type = args.shift.intern
+        limit = args[0] ? args[0].to_i : nil
+        server = DRbQS.create_test_server(@options)
+        case type
+        when :task
+          server.test_task_generator(:limit => limit, :progress => true)
+        when :exec
+          data = server.test_exec(:limit => limit, :profile => @test_opts[:profile], :printer => @test_opts[:printer])
+          if io
+            s = sprintf("Results: %d tasks; total %.4fs", data[:task], data[:end] - data[:start])
+            s << sprintf("; %.4fs per one task", (data[:end] - data[:start]) / data[:task]) if data[:task] > 0
+            s << "\nOutput the profile data to #{data[:profile]}" if data[:profile]
+            io.puts s
+          end
+        else
+          raise DRbQS::Setting::InvalidArgument, "Not yet implemented test '#{type}'"
+        end
+      end
+      private :command_test
+
+      def command_start_server
+        DRbQS.start_server(@options)
+      end
+      private :command_start_server
+
+      def current_server_uri
+        DRbQS::Misc.create_uri(@options)
+      end
+      private :current_server_uri
+
+      def wait_server_process(uri, server_pid = nil)
+        manage = DRbQS::Manage.new(:uri => uri)
+        unless manage.wait_server_process(server_pid)
+          raise "The process of the server of #{uri} does not exist."
+        end
+      rescue DRbQS::Manage::NoServerRespond => err
+        raise DRbQS::Manage::NoServerRespond, "The server of #{uri} does not respond."
+      end
+      private :wait_server_process
+
+      def execute_node_and_wait(uri)
+        node_log_file = nil
+        unless IO === @options[:log_file]
+          node_log_file = FileName.create(@options[:log_file], :add => :always, :position => :middle, :delimiter => '', :format => "_node_%02d")
+        end
+        exec_node = DRbQS::ExecuteNode.new(uri, node_log_file, @options[:log_level])
+        exec_node.execute(@execute_node_number, NODE_INTERVAL_TIME)
+        exec_node.wait
+      end
+      private :execute_node_and_wait
+
+      def command_server_with_nodes
+        server_pid = fork do
+          begin
+            DRbQS.start_server(@options)
+          rescue SystemExit
+          rescue Exception => err
+            $stderr.puts "*** Error occurs on server process #{Process.pid}. ***"
+            output_error(err)
+          end
+        end
+        uri = current_server_uri
+        wait_server_process(uri, server_pid)
+        execute_node_and_wait(uri)
+      end
+      private :command_server_with_nodes
+
+      def command_server_help(io)
+        if io
+          begin
+            get_argument.each do |path|
+              if File.exist?(path)
+                Kernel.load(path)
+              end
+            end
+            if mes = DRbQS.option_help_message
+              io.print "\n" << mes
+            end
+          rescue => err
+            new_err = err.class.new("Error in loading #{path}: #{err.to_s}")
+            new_err.set_backtrace(err.backtrace)
+            raise new_err
+          end
+        end
+      end
+      private :command_server_help
+
+      def setup_arguments
+        get_argument.each do |path|
+          if File.exist?(path)
+            Kernel.load(path)
+          else
+            raise DRbQS::Setting::InvalidArgument, "#{path} does not exist."
+          end
+        end
+        unless @options[:acl]
+          @options[:acl] = DRbQS::Config.new.get_acl_file
+        end
+        DRbQS.parse_option(@server_argument.get_argument)
+      end
+      private :setup_arguments
+
+      def fork_daemon_process
+        if @__daemon__
+          case @command_type
+          when /^test/
+            raise DRbQS::Setting::InvalidArgument, "Test of server does not support daemon"
+          else
+            fork do
+              exec_as_daemon
+            end
+            uri = current_server_uri
+            wait_server_process(uri)
+          end
+          true
+        else
+          nil
+        end
+      end
+      private :fork_daemon_process
+
+      def exec(io = nil)
+        if @command_type == :help
+          command_server_help(io)
+        elsif !fork_daemon_process
+          setup_arguments
+          case @command_type
+          when /^test/
+            command_test(io)
+          else
+            if @execute_node_number
+              command_server_with_nodes
+            else
+              command_start_server
+            end
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/drbqs/setting/setting.rb

@@ -0,0 +1,14 @@
+require 'drbqs/command_line/argument'
+require 'drbqs/setting/data_container'
+require 'drbqs/setting/source'
+require 'drbqs/setting/base'
+
+module DRbQS
+  class Setting
+    autoload :Server, 'drbqs/setting/server'
+    autoload :Node, 'drbqs/setting/node'
+    autoload :Manage, 'drbqs/setting/manage'
+    autoload :SSH, 'drbqs/setting/ssh'
+    autoload :Execute, 'drbqs/setting/execute'
+  end
+end