drbqs 0.0.14 → 0.0.15

data/lib/drbqs/setting/source.rb

@@ -0,0 +1,220 @@
+module DRbQS
+  class Setting
+    class InvalidArgument < StandardError
+    end
+
+    class Source
+      attr_reader :value, :default
+
+      def initialize(all_keys_defined = true)
+        @cond = {}
+        @default = {}
+        @value = DRbQS::Setting::Source::DataContainer.new(Array)
+        @argument_condition = nil
+        @all_keys_defined = all_keys_defined
+      end
+
+      def clone
+        new_obj = self.class.new(!!@all_keys_defined)
+        args = [@cond.clone, @default.clone, DRbQS::Setting::Source.clone_container(@value), @argument_condition]
+        new_obj.instance_exec(*args) do |cond, default, value, arg_cond|
+          @cond = cond
+          @default = default
+          @value = value
+          @argument_condition = arg_cond
+        end
+        new_obj
+      end
+
+      # For debug.
+      def registered_keys
+        @cond.keys
+      end
+
+      def registered_key?(key)
+        @cond.has_key?(key)
+      end
+      private :registered_key?
+
+      def boolean_value?(key)
+        registered_key?(key) && @cond[key][:bool]
+      end
+      private :boolean_value?
+
+      def value_to_add?(key)
+        registered_key?(key) && @cond[key][:add]
+      end
+      private :value_to_add?
+
+      def check_argument_array_size(check, args, target = nil)
+        n = args.size
+        check.each_slice(2).each do |ary|
+          unless n.__send__(*ary)
+            mes = "Size"
+            if target
+              mes << " of #{target.inspect}"
+            end
+            mes << " must be " << ary.map(&:to_s).join(' ') << ", but #{n}"
+            raise DRbQS::Setting::InvalidArgument, mes
+          end
+        end
+      end
+      private :check_argument_array_size
+
+      def check!
+        if @argument_condition
+          check_argument_array_size(@argument_condition, get_argument, "argument array")
+        end
+        keys = @value.__data__.keys
+        keys.each do |key|
+          args = @value.__data__[key]
+          unless Symbol === key
+            key = key.intern
+            @value.__data__.delete(key)
+          end
+          if registered_key?(key)
+            if check = @cond[key][:check]
+              check_argument_array_size(check, args, key)
+            end
+          elsif @all_keys_defined
+            raise DRbQS::Setting::InvalidArgument, "Undefined key '#{key.inspect}' must not set."
+          end
+          if boolean_value?(key)
+            @value.__data__[key] = [(args.size == 0 || args[0] ? true : false)]
+          else
+            @value.__data__[key] = args
+          end
+        end
+      end
+
+      def parse_condition(check)
+        if Fixnum === check
+          [:==, check]
+        elsif check.size == 1 && Fixnum === check[0]
+          [:==, check[0]]
+        elsif Array === check && check.size.even?
+          check
+        else
+          raise DRbQS::Setting::InvalidArgument, "Invalid argument condition."
+        end
+      end
+      private :parse_condition
+
+      # :check
+      # :add
+      # :bool
+      # :default
+      def register_key(key, opts = {})
+        k = key.intern
+        if registered_key?(k)
+          @cond[k].clear
+        else
+          @cond[k] = {}
+        end
+        if check = opts[:check]
+          @cond[k][:check] = parse_condition(check)
+        end
+        if default = opts[:default]
+          check_argument_array_size(@cond[k][:check], default, "default of #{k.inspect}") if @cond[k][:check]
+          @default[k] = default
+        end
+        @cond[k][:add] = opts[:add]
+        @cond[k][:bool] = opts[:bool]
+      end
+
+      def set_argument_condition(*checks)
+        @argument_condition = parse_condition(checks)
+      end
+
+      def set(key, *args)
+        k = key.intern
+        if value_to_add?(key) && @value.__data__[k]
+          @value.__data__[k].concat(args)
+        else
+          @value.__data__[k] = args
+        end
+      end
+
+      def clear(key)
+        @value.__data__.delete(key.intern)
+      end
+
+      def get(key, &block)
+        k = key.intern
+        val = @value.__data__[k] || @default[k]
+        if block_given? && val
+          yield(val)
+        else
+          val
+        end
+      end
+
+      def get_first(key, &block)
+        val = get(key) do |ary|
+          ary[0]
+        end
+        block_given? && val ? yield(val) : val
+      end
+
+      def set?(key)
+        !!@value.__data__[key.intern]
+      end
+
+      def set_argument(*args)
+        @value.argument = args
+      end
+
+      def get_argument
+        @value.argument
+      end
+
+      def escape_string_for_shell(str)
+        '"' << str.gsub(/"/, '\"') << '"'
+      end
+      private :escape_string_for_shell
+
+      def argument_array_for_command_line(escape)
+        ary = get_argument.map do |val|
+          val.to_s
+        end
+        if escape
+          ary.map! do |val|
+            escape_string_for_shell(val)
+          end
+        end
+        ary
+      end
+      private :argument_array_for_command_line
+
+      def option_array_for_command_line(escape)
+        ary = []
+        @value.__data__.each do |k, val|
+          s = k.to_s
+          s.strip!
+          if s.size > 0
+            option_key = (s.size == 1 ? "-#{s}" : "--#{s}")
+            option_key.gsub!(/_/, '-')
+            if !@cond[k][:bool]
+              val.each do |v|
+                ary << option_key
+                value_string = v.to_s
+                if escape
+                  value_string = escape_string_for_shell(value_string)
+                end
+                ary << value_string
+              end
+            elsif val
+              ary << option_key
+            end
+          end
+        end
+        ary
+      end
+      private :option_array_for_command_line
+
+      def command_line_argument(escape = nil)
+        argument_array_for_command_line(escape) + option_array_for_command_line(escape)
+      end
+    end
+  end
+end

data/lib/drbqs/setting/ssh.rb

@@ -0,0 +1,165 @@
+module DRbQS
+  class Setting
+    class SSH < DRbQS::Setting::Base
+      include DRbQS::Command::Argument
+
+      attr_accessor :mode_setting
+
+      def initialize
+        super(:all_keys_defined => true) do
+          [:directory, :shell, :rvm, :rvm_init, :output, :connect].each do |key|
+            register_key(key, :check => 1)
+          end
+          register_key(:nice, :check => 1, :default => [10])
+          set_argument_condition(:>=, 0)
+        end
+        @mode_setting = nil
+      end
+
+      def configure_mode_setting(type = nil, &block)
+        if type ||= get_argument[0]
+          unless @mode_setting
+            case type.intern
+            when :server
+              @mode_setting = DRbQS::Setting::Server.new
+            when :node
+              @mode_setting = DRbQS::Setting::Node.new
+            else
+              @mode_setting = DRbQS::Setting::Base.new
+            end
+          end
+          yield(@mode_setting.value)
+        else
+          raise DRbQS::Setting::InvalidArgument, "Command mode is not determined."
+        end
+      end
+
+      def command_line_argument(escape = nil)
+        ary = super(escape)
+        ssh_args = @mode_setting.command_line_argument(escape)
+        if ssh_args.size > 0
+          ary << '--'
+          ary.concat(ssh_args)
+        end
+        ary
+      end
+
+      def preprocess!
+        if connect = get_first(:connect)
+          value.argument << connect
+          clear(:connect)
+        end
+        if type = get_argument[0]
+          case type.intern
+          when :server
+            @mode_setting.clear(:log_file)
+            @mode_setting.clear(:daemon)
+          when :node
+            @mode_setting.clear(:log_prefix)
+            @mode_setting.clear(:daemon)
+          end
+        end
+      end
+      private :preprocess!
+
+      # If there are invalid arguments,
+      # this method raises an error.
+      def parse!
+        super
+        [:directory, :shell, :rvm, :rvm_init, :nice].each do |key|
+          if val = get_first(key)
+            @options[key] = val
+          end
+        end
+        @output = get_first(:output)
+        ary = get_argument
+        @command = ary[0]
+        @argv = ary[1..-1]
+        @mode_setting.parse!
+        @mode_argument_array = @mode_setting.command_line_argument
+      end
+
+      def command_list(io)
+        if io
+          ssh_host = DRbQS::Config.new.ssh_host
+          io.puts ssh_host.config_names.join("\n")
+        end
+      end
+      private :command_list
+
+      def only_first_argument
+        check_argument_size(@argv, :==, 1)
+        @argv[0]
+      end
+      private :only_first_argument
+
+      def connecting_ssh_server
+        only_first_argument
+      end
+      private :connecting_ssh_server
+
+      def command_show(io)
+        if io
+          name = only_first_argument
+          ssh_host = DRbQS::Config.new.ssh_host
+          if path = ssh_host.get_path(name)
+            io.puts File.read(path)
+          else
+            raise DRbQS::Setting::InvalidArgument, "Can not find configuration file '#{name}'."
+          end
+        end
+      end
+      private :command_show
+
+      def manage_ssh(dest, io)
+        DRbQS::Manage::SSHExecute.new(dest, { :io => io }.merge(@options))
+      end
+      private :manage_ssh
+
+      def command_environment(io)
+        dest = only_first_argument
+        manage_ssh(dest, io).get_environment
+      end
+      private :command_environment
+
+      def command_execute(io)
+        mng_ssh = manage_ssh(connecting_ssh_server, io)
+        if @mode_argument_array.size > 0
+          mng_ssh.command(@mode_argument_array)
+        else
+          raise "There is no command for ssh."
+        end
+      end
+      private :command_execute
+
+      def command_server(io)
+        manage_ssh(connecting_ssh_server, io).server(@mode_argument_array, :nice => @nice, :daemon => @output)
+      end
+      private :command_server
+
+      def command_node(io)
+        manage_ssh(connecting_ssh_server, io).node(@mode_argument_array, :nice => @nice, :daemon => @output)
+      end
+      private :command_node
+
+      def exec(io = nil)
+        case @command
+        when 'list'
+          command_list(io)
+        when 'show'
+          command_show(io)
+        when 'environment'
+          command_environment(io)
+        when 'execute'
+          command_execute(io)
+        when 'server'
+          command_server(io)
+        when 'node'
+          command_node(io)
+        else
+          raise DRbQS::Setting::InvalidArgument, "Invalid command '#{@command}'."
+        end
+      end
+    end
+  end
+end

data/lib/drbqs/task/task_generator.rb

@@ -54,14 +54,16 @@ module DRbQS
       @iterate = opts[:generate] || 1
       @task_set = opts[:collect]
       if @iterate < 1 || (@task_set && @task_set < 1)
-        raise ArgumentError, "Invalid option."
+        raise ArgumentError, "Invalid options of task creation on generator."
       end
       @fiber_init = lambda do
         @fiber = Fiber.new do
           begin
             @source.instance_eval(&block)
           rescue => err
-            raise DRbQS::TaskCreatingError, "\n  #{err.to_s}\n#{err.backtrace.join("\n")}"
+            new_err = DRbQS::TaskCreatingError.new("#{err.to_s} (#{err.class}) when creating task")
+            new_err.set_backtrace(err.backtrace)
+            raise new_err
           end
           nil
         end

data/lib/drbqs/utility/misc.rb

@@ -16,10 +16,15 @@ module DRbQS
   end
 
   module Misc
+    # :port
+    # :host
+    # :unix
     def create_uri(opts = {})
       if opts[:port] || !opts[:unix]
         port = opts[:port] || ROOT_DEFAULT_PORT
-        "druby://:#{port}"
+        "druby://#{opts[:host]}:#{port}"
+      elsif opts[:host]
+        raise ArgumentError, "We can not set hostname to unix domain socket."
       else
         path = File.expand_path(opts[:unix])
         if !File.directory?(File.dirname(path))
@@ -67,6 +72,15 @@ module DRbQS
       Integer === pid && (ps_table = Sys::ProcTable.ps(pid)) && (ps_table.state != 'Z')
     end
     module_function :process_running_normally?
+
+    def output_error(err, io = $stderr)
+      backtrace = err.backtrace
+      io.puts "#{backtrace[0]}: #{err.to_s} (#{err.class})"
+      if backtrace.size > 1
+        io.puts "        from #{backtrace[1..-1].join("\n        from ")}"
+      end
+    end
+    module_function :output_error
   end
 
 end

data/lib/drbqs/utility/temporary.rb

@@ -1,3 +1,5 @@
+require 'tmpdir'
+
 module DRbQS
   module Temporary
     @@root = nil
@@ -7,8 +9,8 @@ module DRbQS
     def self.filename
       unless @@filename
         pid = Process.pid
-        @@root = sprintf("/tmp/drbqs_%d_%d", pid, rand(10000))
-        FileUtils.mkdir_p(@@root)
+        @@root = File.join(Dir.tmpdir, sprintf("drbqs_%d_%d", pid, rand(10000)))
+        FileUtils.mkdir_p(@@root, :mode => 0700)
         @@filename = FileName.new(File.join(@@root, sprintf("temp_%d_%d", pid, rand(10000))))
       end
       @@filename

data/lib/drbqs.rb

@@ -9,15 +9,16 @@ require 'fileutils'
 
 require 'filename'
 
-require 'drbqs/utility/server_define'
+require 'drbqs/execute/server_define'
 require 'drbqs/utility/misc'
 
 module DRbQS
   autoload :Server, 'drbqs/server/server'
   autoload :Node, 'drbqs/node/node'
   autoload :Config, 'drbqs/config/config'
+  autoload :Setting, 'drbqs/setting/setting'
 
   ROOT_DEFAULT_PORT = 13500
 
-  VERSION = '0.0.14'
+  VERSION = '0.0.15'
 end

data/spec/command_line/command_base_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/command_line/command_line'
+
+describe DRbQS::Command::Base do
+  context "when executing" do
+    it "should execute." do
+      setting = mock('setting')
+      DRbQS::Setting::Base.stub(:new).and_return(setting)
+      setting.should_receive(:parse!)
+      setting.should_receive(:exec).with($stdout)
+      command_base = DRbQS::Command::Base.new(DRbQS::Setting::Base, 'help message')
+      command_base.should_receive(:exit_normally)
+      command_base.exec
+    end
+
+    it "should define DRbQS::Command::Base.exec." do
+      argv = [1, 2, 3]
+      obj = mock
+      DRbQS::Command::Base.should_receive(:new).and_return(obj)
+      obj.should_receive(:parse_option)
+      obj.should_receive(:exec)
+      DRbQS::Command::Base.exec(argv)
+    end
+  end
+
+  context "when existing" do
+    subject do
+      DRbQS::Command::Base.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
+end

data/spec/{utility/command_line → command_line}/commands_spec.rb

@@ -1,8 +1,8 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-require 'drbqs/utility/command_line'
+require 'drbqs/command_line/command_line'
 
-[DRbQS::CommandServer, DRbQS::CommandNode, DRbQS::CommandManage, DRbQS::CommandSSH].each do |cls|
+[DRbQS::Command::Server, DRbQS::Command::Node, DRbQS::Command::Manage, DRbQS::Command::SSH].each do |cls|
   describe cls do
     it "should have defined parse_option." do
       cls.method_defined?(:parse_option).should be_true

data/spec/command_line/option_setting_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'drbqs/command_line/command_line'
+
+describe DRbQS::Command::OptionSetting do
+  subject do
+    DRbQS::Command::OptionSetting.new('help message', DRbQS::Setting::Base.new)
+  end
+
+  it "should set log_level option." do
+    subject.define(:log_level => true)
+    subject.parse!(['--log-level', 'debug']).should be_empty
+    subject.setting.get(:log_level).should == ['debug']
+  end
+
+  it "should set daemon option." do
+    subject.define(:daemon => true)
+    subject.parse!(['--daemon', '/path/to/log', 'other options']).should == ['other options']
+    subject.setting.get(:daemon).should == ['/path/to/log']
+  end
+
+  it "should set an arbitrary option." do
+    subject.define do
+      set(:new_opt, '--new-opt NUM', Integer, 'Set the number.')
+    end
+    subject.parse!(['--new-opt', '123', 'HELLO']).should == ['HELLO']
+    subject.setting.get(:new_opt).should == [123]
+  end
+end

data/spec/execute/def/execute1.rb

@@ -0,0 +1,24 @@
+# Use in process_define_spec.rb
+
+server_file = File.join(File.dirname(__FILE__), '../../integration_test/definition/server02.rb')
+usage message: "Usage of this definition.", server: server_file
+
+default log: '/tmp/drbqs_tmp_log'
+
+register_server 'server_local', 'localhost' do |server|
+  server.load server_file
+end
+
+register_server 'server_ssh', 'example.com' do |server, ssh|
+  ssh.connect "example.com"
+  server.load 'server.rb'
+end
+
+register_node 'node_local' do |node|
+  node.log_level = Logger::DEBUG
+end
+
+register_node 'node_ssh' do |node, ssh|
+  ssh.connect "example.com"
+  node.log_level = Logger::DEBUG
+end

data/spec/execute/def/no_def.rb

@@ -0,0 +1,2 @@
+# Use in process_define_spec.rb
+