drbqs 0.0.14 → 0.0.15

data/lib/drbqs/utility/command_line/command_manage.rb

@@ -1,121 +0,0 @@
-module DRbQS
-  class CommandManage < CommandBase
-    HELP_MESSAGE =<<HELP
-Usage: #{@@command_name} <command> [arguments ...]
-  Manage DRbQS server by sending messages.
-  <command> is 'signal', 'status', 'process', or 'initialize'.
-
-  #{@@command_name} signal <uri> server-exit
-  #{@@command_name} signal <uri> node-exit-after-task <node_number>
-  #{@@command_name} status <uri>
-  #{@@command_name} process list
-  #{@@command_name} process clear
-  #{@@command_name} initialize
-
-HELP
-
-    def parse_option(argv)
-      begin
-        OptionParser.new(HELP_MESSAGE) do |opt|
-          opt.on('--debug', 'Set $DEBUG true.') do |v|
-            $DEBUG = true
-          end
-          opt.parse!(argv)
-        end
-      rescue OptionParser::InvalidOption
-        $stderr.print "error: Invalid Option\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      rescue OptionParser::InvalidArgument
-        $stderr.print "error: Invalid Argument\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      end
-      @mode = argv.shift
-      @argv = argv
-      @manage = DRbQS::Manage.new
-    end
-
-    def command_initialize
-      check_argument_size(@argv, :>=, 0, :<=, 1)
-      @manage.set_home_directory(@argv[0])
-      @manage.create_config
-      exit_normally
-    end
-    private :command_initialize
-
-    def command_process
-      check_argument_size(@argv, :>=, 0, :<=, 1)
-      if @argv[0] == 'clear'
-        @manage.clear_process
-        exit_normally
-      end
-      list = @manage.list_process
-      $stdout.puts "Server"
-      list[:server].each do |uri, data|
-        $stdout.puts "#{uri}"
-        data.each do |k, v|
-          $stdout.puts sprintf("  %-10s  %s", k, v)
-        end
-      end
-      $stdout.puts "\nNode"
-      list[:node].each do |pid, data|
-        $stdout.puts "#{pid}"
-        data.each do |k, v|
-          $stdout.puts sprintf("  %-10s  %s", k, v)
-        end
-      end
-      exit_normally
-    end
-    private :command_process
-
-    def command_status
-      check_argument_size(@argv, :==, 1)
-      @manage.set_uri(@argv[0])
-      if status = @manage.get_status
-        $stdout.puts status
-      end
-      exit_normally
-    end
-    private :command_status
-
-    def command_signal
-      @manage.set_uri(@argv[0])
-      signal = @argv[1]
-      case signal
-      when 'server-exit'
-        check_argument_size(@argv, :==, 2)
-        @manage.send_exit_signal
-        exit_normally
-      when 'node-exit-after-task'
-        check_argument_size(@argv, :==, 3)
-        node_id = @argv[2].to_i
-        @manage.send_node_exit_after_task(node_id)
-        exit_normally
-      else
-        $stderr.print "error: Invalid signal '#{signal}'\n\n" << HELP_MESSAGE
-        exit_unusually
-      end
-    end
-    private :command_signal
-
-    def exec
-      case @mode
-      when 'initialize'
-        command_initialize
-      when 'process'
-        command_process
-      when 'status'
-        command_status
-      when 'signal'
-        command_signal
-      end
-      $stderr.print "error: Invalid command '#{@mode}'\n\n" << HELP_MESSAGE
-      exit_invalid_option
-    rescue DRb::DRbConnError => err
-      $stderr.puts "error: Can not connect server: #{err.to_s}"
-      exit_unusually
-    rescue => err
-      $stderr.print "error: #{err.to_s}\n" << err.backtrace.join("\n")
-      exit_unusually
-    end
-  end
-end

data/lib/drbqs/utility/command_line/command_node.rb

@@ -1,103 +0,0 @@
-module DRbQS
-  class CommandNode < CommandBase
-    HELP_MESSAGE =<<HELP
-Usage: #{@@command_name} [<uri>] [<process_number>] [options ...]
-  Start DRbQS nodes connecting to <uri>.
-
-HELP
-
-    LOG_PREFIX_DEFAULT = 'drbqs_node'
-    LOG_LEVEL_DEFAULT = Logger::ERROR
-
-    def parse_option(argv)
-      options = {
-        :log_prefix => LOG_PREFIX_DEFAULT,
-        :log_level => LOG_LEVEL_DEFAULT,
-        :load => []
-      }
-
-      begin
-        OptionParser.new(HELP_MESSAGE) do |opt|
-          opt.on('-l', '--load FILE', String, 'Add a file to load.') do |v|
-            options[:load] << File.expand_path(v)
-          end
-          opt.on('--log-prefix STR', String, "Set the prefix of log files. The default is '#{LOG_PREFIX_DEFAULT}'.") do |v|
-            options[:log_prefix] = v
-          end
-          opt.on('--log-level LEVEL', String,
-                 "Set the log level. The value accepts 'fatal', 'error', 'warn', 'info', and 'debug'. The default is 'error'.") do |v|
-            if /^(fatal)|(error)|(warn)|(info)|(debug)$/i =~ v
-              options[:log_level] = eval("Logger::#{v.upcase}")
-            else
-              $stderr.print "error: Invalid log level.\n\n" << HELP_MESSAGE
-              exit_invalid_option
-            end
-          end
-          opt.on('--log-stdout', 'Use stdout for outputting logs. This option cancels --log-prefix.') do |v|
-            options[:log_prefix] = nil
-          end
-          opt.on('--debug', 'Set $DEBUG true.') do |v|
-            $DEBUG = true
-          end
-          opt.parse!(argv)
-        end
-      rescue OptionParser::InvalidOption
-        $stderr.print "error: Invalid Option\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      rescue OptionParser::InvalidArgument
-        $stderr.print "error: Invalid Argument\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      end
-      @options = options
-      @argv = argv
-    end
-
-    def parse_argv_array
-      process_num = 1
-      uri = nil
-      @argv.each do |arg|
-        if /^\d+$/ =~ arg
-          process_num = arg.to_i
-        elsif uri
-          $stderr.print "error: More than one uris is set.\n\n" << HELP_MESSAGE
-          exit_invalid_option
-        else
-          uri = arg
-        end
-      end
-      uri ||= DRbQS::Misc.create_uri
-      [process_num, uri]
-    end
-    private :parse_argv_array
-
-    def exec
-      if @argv.size > 2
-        $stderr.print "error: Too many arguments.\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      end
-      process_num, uri = parse_argv_array
-
-      @options[:load].each do |v|
-        $stdout.puts "load #{v}"
-        load v
-      end
-
-      $stdout.puts "Connect to #{uri}"
-      $stdout.puts "Execute #{process_num} processes"
-
-      if @options[:log_prefix]
-        if /\/$/ =~ @options[:log_prefix]
-          @options[:log_prefix] += 'out'
-        end
-      end
-
-      exec_node = DRbQS::ExecuteNode.new(uri, @options[:log_prefix], @options[:log_level])
-      exec_node.execute(process_num)
-      exec_node.wait
-      exit_normally
-    rescue => err
-      $stderr.print "error: #{err.to_s}\n" << err.backtrace.join("\n")
-      exit_unusually
-    end
-  end
-end

data/lib/drbqs/utility/command_line/command_server.rb

@@ -1,165 +0,0 @@
-module DRbQS
-  class CommandServer < CommandBase
-    @@command_name = File.basename($PROGRAM_NAME)
-
-    HELP_MESSAGE =<<HELP
-Usage: #{@@command_name} <definition.rb> [other files ...] [options ...]
-       #{@@command_name} <definition.rb> [other files ...] [options ...] -- [server options ...]
-  Start DRbQS server of definition files.
-
-HELP
-
-    NODE_INTERVAL_TIME = 1
-
-    def parse_option(argv)
-      @options = {
-        :log_file => STDOUT
-      }
-      @command_type = :server_start
-
-      test_opts = {}
-      @execute_node_number = nil
-      @command_argv, @server_argv = split_arguments(argv)
-
-      begin
-        OptionParser.new(HELP_MESSAGE) do |opt|
-          opt.on('-p PORT', '--port', Integer, 'Set the port number of server.') do |v|
-            @options[:port] = v
-          end
-          opt.on('-u PATH', '--unix', String, 'Set the path of unix domain socket.') do |v|
-            @options[:unix] = v
-          end
-          opt.on('--acl FILE', String, 'Set a file to define ACL.') do |v|
-            @options[:acl] = v
-          end
-          opt.on('--log-file STR', String, "Set the path of log file. If this options is not set, use STDOUT.") do |v|
-            @options[:log_file] = v
-          end
-          opt.on('--log-level LEVEL', String,
-                 "Set the log level. The value accepts 'fatal', 'error', 'warn', 'info', and 'debug'. The default is 'error'.") do |v|
-            if /^(fatal)|(error)|(warn)|(info)|(debug)$/i =~ v
-              @options[:log_level] = eval("Logger::#{v.upcase}")
-            else
-              $stderr.print "error: Invalid log level.\n\n" << HELP_MESSAGE
-              exit_invalid_option
-            end
-          end
-          opt.on('--file-directory DIR', String, 'Set the file archive directory.') do |v|
-            @options[:file_directory] = v
-          end
-          opt.on('--sftp-user USER', String, 'Set the user of sftp destination.') do |v|
-            @options[:sftp_user] = v
-          end
-          opt.on('--sftp-host HOST', String, 'Set the host of sftp destination.') do |v|
-            @options[:sftp_host] = v
-          end
-          opt.on('--profile', 'Use profile for test exec.') do |v|
-            @test_opts[:profile] = true
-          end
-          opt.on('--debug', 'Set $DEBUG true.') do |v|
-            $DEBUG = true
-          end
-          opt.on('--test STR', String, 'Execute test.') do |v|
-            @command_type = "test_#{v}"
-          end
-          opt.on('--execute-node NUM', Integer, 'Execute nodes.') do |v|
-            @execute_node_number = v
-          end
-          opt.on('-h', '--help', 'Show help.') do |v|
-            $stdout.print opt
-            @command_type = :help
-          end
-          opt.parse!(@command_argv)
-        end
-      rescue OptionParser::InvalidOption
-        $stderr.print "error: Invalid Option\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      rescue OptionParser::InvalidArgument
-        $stderr.print "error: Invalid Argument\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      end
-    end
-
-    def command_test
-      s = @command_type.split('_')[1].split(',')
-      type = s[0].intern
-      DRbQS.test_server(@options, type, s[1..-1], @test_opts)
-    end
-    private :command_test
-
-    def command_start_server
-      DRbQS.start_server(@options)
-    end
-    private :command_start_server
-
-    def command_server_with_nodes
-      server_pid = fork do
-        DRbQS.start_server(@options)
-      end
-      uri = DRbQS::Misc.create_uri(@options)
-      manage = DRbQS::Manage.new(:uri => uri)
-      if manage.wait_server_process(server_pid)
-        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
-      else
-        $stderr.puts "error: Server has been terminated."
-        exit_unusually
-      end
-    end
-    private :command_server_with_nodes
-
-    def command_server_help
-      begin
-        @command_argv.each do |path|
-          if File.exist?(path)
-            load path
-          end
-        end
-        if mes = DRbQS.option_help_message
-          $stdout.print "\n" << mes
-        end
-      rescue => err
-        $stderr.print "error: Load invalid file.\n#{err.to_s}\n#{err.backtrace.join("\n")}"
-        exit_invalid_option
-      end
-      exit_normally
-    end
-    private :command_server_help
-
-    def exec
-      if @command_type == :help
-        command_server_help
-      end
-      if @command_argv.size == 0 || !(@command_argv.all? { |path| File.exist?(path) })
-        $stderr.print "error: There are nonexistent files.\n\n" << HELP_MESSAGE
-        exit_unusually
-      end
-      @command_argv.each do |path|
-        load path
-      end
-      unless @options[:acl]
-        @options[:acl] = DRbQS::Config.new.get_acl_file
-      end
-      DRbQS.parse_option(@server_argv)
-      case @command_type
-      when /^test/
-        command_test
-      else
-        if @execute_node_number
-          command_server_with_nodes
-        else
-          command_start_server
-        end
-      end
-      exit_normally
-    rescue => err
-      $stderr.print "error: #{err.to_s}\n" << err.backtrace.join("\n")
-      exit_unusually
-    end
-  end
-end

data/lib/drbqs/utility/command_line/command_ssh.rb

@@ -1,126 +0,0 @@
-module DRbQS
-  class CommandSSH < CommandBase
-    HELP_MESSAGE =<<HELP
-Usage: #{@@command_name} <command> [arguments ...]
-  Execute command over SSH.
-  <command> is 'list', 'show', 'execute', or 'environment'
-
-  #{@@command_name} list
-  #{@@command_name} show <configuration>
-  #{@@command_name} environment <destination>
-  #{@@command_name} execute <destination>
-
-HELP
-
-    def parse_option(argv)
-      options = {}
-      argv, command_args = split_arguments(argv)
-
-      begin
-        OptionParser.new(HELP_MESSAGE) do |opt|
-          opt.on('--debug', 'Set $DEBUG true.') do |v|
-            $DEBUG = true
-          end
-          opt.on('--dir DIR', String, 'Set the base directory over ssh.') do |v|
-            options[:dir] = v
-          end
-          opt.on('--shell STR', String, 'Set the shell over ssh') do |v|
-            options[:shell] = v
-          end
-          opt.on('--rvm STR', String, 'Ruby version to use on RVM over ssh.') do |v|
-            options[:rvm] = v
-          end
-          opt.on('--rvm-init PATH', String, 'Path of script to initialize RVM over ssh.') do |v|
-            options[:rvm_init] = v
-          end
-          opt.on('--output PATH', String, 'File path that stdout and stderr are output to over ssh.') do |v|
-            options[:output] = v
-          end
-          opt.on('--nice NUM', Integer, 'Set the value for nice command.') do |v|
-            options[:nice] = v
-          end
-          opt.on('--nohup', 'Use nohup command.') do |v|
-            options[:nohup] = true
-          end
-          opt.parse!(argv)
-        end
-      rescue OptionParser::InvalidOption
-        $stderr.print "error: Invalid Option\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      rescue OptionParser::InvalidArgument
-        $stderr.print "error: Invalid Argument\n\n" << HELP_MESSAGE
-        exit_invalid_option
-      end
-      @options = options
-      @command = argv.shift
-      @argv = argv
-      @command_args = command_args
-    end
-
-    def command_list
-      ssh_host = DRbQS::Config.new.ssh_host
-      $stdout.puts ssh_host.config_names.join("\n")
-      exit_normally
-    end
-    private :command_list
-
-    def command_show
-      check_argument_size(@argv, :==, 1)
-      name = @argv[0]
-      ssh_host = DRbQS::Config.new.ssh_host
-      if path = ssh_host.get_path(name)
-        $stdout.puts File.read(path)
-        exit_normally
-      else
-        $stderr.print "Can not find configuration file '#{name}'."
-        exit_unusually
-      end
-    end
-    private :command_show
-
-    def manage_ssh(dest)
-      DRbQS::Manage::SSHExecute.new(dest, @options)
-    end
-    private :manage_ssh
-
-    def command_environment
-      check_argument_size(@argv, :==, 1)
-      dest = @argv[0]
-      manage_ssh(dest).get_environment
-      exit_normally
-    end
-    private :command_environment
-
-    def command_execute
-      check_argument_size(@argv, :==, 1)
-      dest = @argv[0]
-      mng_ssh = manage_ssh(dest)
-      if @command_args.size > 0
-        mng_ssh.execute(@command_args)
-        exit_normally
-      else
-        $stderr.print "error: There is no command for ssh.\n\n" << HELP_MESSAGE
-        exit_unusually
-      end
-    end
-    private :command_execute
-
-    def exec
-      case @command
-      when 'list'
-        command_list
-      when 'show'
-        command_show
-      when 'environment'
-        command_environment
-      when 'execute'
-        command_execute
-      end
-      $stderr.print "error: Invalid command '#{@command}'.\n\n" << HELP_MESSAGE
-      exit_invalid_option
-    rescue => err
-      $stderr.print "error: #{err.to_s}\n" << err.backtrace.join("\n")
-      exit_unusually
-    end
-  end
-end

data/lib/drbqs/utility/command_line.rb

@@ -1,15 +0,0 @@
-require 'drbqs'
-require 'drbqs/utility/argument'
-require 'drbqs/manage/manage'
-require 'drbqs/manage/execute_node'
-require 'drbqs/utility/command_line/command_base'
-require 'optparse'
-
-Version = DRbQS::VERSION
-
-module DRbQS
-  autoload :CommandManage, 'drbqs/utility/command_line/command_manage'
-  autoload :CommandServer, 'drbqs/utility/command_line/command_server'
-  autoload :CommandNode, 'drbqs/utility/command_line/command_node'
-  autoload :CommandSSH, 'drbqs/utility/command_line/command_ssh'
-end

data/spec/utility/command_line/command_base_spec.rb

@@ -1,33 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-require 'drbqs/utility/command_line'
-
-describe DRbQS::CommandBase do
-  it "should define DRbQS::CommandBase.exec." do
-    argv = [1, 2, 3]
-    obj = mock
-    DRbQS::CommandBase.should_receive(:new).and_return(obj)
-    obj.should_receive(:parse_option)
-    obj.should_receive(:exec)
-    DRbQS::CommandBase.exec(argv)
-  end
-
-  subject do
-    DRbQS::CommandBase.new
-  end
-
-  it "should exit with 0." do
-    Kernel.should_receive(:exit).with(0)
-    subject.__send__(:exit_normally)
-  end
-
-  it "should exit." do
-    Kernel.should_receive(:exit)
-    subject.__send__(:exit_unusually)
-  end
-
-  it "should exit." do
-    Kernel.should_receive(:exit)
-    subject.__send__(:exit_invalid_option)
-  end
-end