rbatch 2.1.1 → 2.1.2

data/lib/rbatch/cmd.rb

@@ -1,87 +1,52 @@
 require 'fileutils'
 require 'tempfile'
 require 'tmpdir'
-
+require 'timeout'
 module RBatch
 
-  # External command runcher.
-  #
-  #This module is a wrapper of Kernel#spawn.
-  #
-  # * Arguments(cmd_params) are inputed to Kernel#spawn directly and run command.
-  # * Return an object of RBatch::CmdResult which includes stdout, stderr, and exit status.
-  #
-  # ==== Sample 1
-  #  require 'rbatch'
-  #  result = RBatch::cmd("ls")
-  #  p result.stdout
-  #  => "fileA\nfileB\n"
-  #
-  # ==== Sample 2 (use option)
-  #  require 'rbatch'
-  #  result = RBatch::cmd("ls",{:timeout => 1})
-  #  p result.stdout
-  #  => "fileA\nfileB\n"
-  #
-  # ==== Sample 3 (use instance)
-  #  require 'rbatch'
-  #  cmd = RBatch::Cmd.new("ls")
-  #  result = cmd.run
-  #  p result.stdout
-  #  => "fileA\nfileB\n"
-  #
   class Cmd
+    @@def_vars
+    def Cmd.def_vars=(a)    ; @@def_vars=a ; end
     @cmd_str
     @opt
-
-    # Cmd instance
-    #
-    # ==== Params
-    # +cmd_str+ = Command string such as "ls -l"
-    # +opt+ = Option hash object.
-    # - +:raise+ (Boolean) = If command exit status is not 0, raise exception. Default is false.
-    # - +:timeout+ (Integer) = If command timeout , raise exception and kill process. Default is 0 sec ( 0 means disable) .
+    @vars
     def initialize(cmd_str,opt = nil)
       raise(CmdException,"Command string is nil") if cmd_str.nil?
       @cmd_str = cmd_str
-      tmp = {}
-      if opt.nil?
-        @opt=RBatch.run_conf.clone
-      else
+      @vars = @@def_vars.clone
+      if ! opt.nil?
+        # change opt key from "hoge" to "log_hoge"
+        tmp = {}
         opt.each_key do |key|
           tmp[("cmd_" + key.to_s).to_sym] = opt[key]
         end
-        @opt=RBatch.run_conf.merge(tmp)
+        @vars.merge!(tmp)
       end
     end
 
-    # Run command
-    #
-    # ==== Return
-    # instance of RBatch::CmdResult
     def run()
       stdout_file = Tempfile::new("rbatch_tmpout",Dir.tmpdir)
       stderr_file = Tempfile::new("rbatch_tmperr",Dir.tmpdir)
       pid = spawn(@cmd_str,:out => [stdout_file,"w"],:err => [stderr_file,"w"])
       status = nil
-      if @opt[:cmd_timeout] != 0
+      if @vars[:cmd_timeout] != 0
         begin
-          timeout(@opt[:cmd_timeout]) do
+          timeout(@vars[:cmd_timeout]) do
             status =  Process.waitpid2(pid)[1] >> 8
           end
         rescue Timeout::Error => e
           begin
             Process.kill('SIGINT', pid)
-            raise(CmdException,"Run time of command \"#{@cmd_str}\" is over #{@opt[:cmd_timeout].to_s} sec. Success to kill process : PID=#{pid}" )
+            raise(CmdException,"Run time of command \"#{@cmd_str}\" is over #{@vars[:cmd_timeout].to_s} sec. Success to kill process : PID=#{pid}" )
           rescue
-            raise(CmdException,"Run time of command \"#{@cmd_str}\" is over #{@opt[:cmd_timeout].to_s} sec. Fail to kill process : PID=#{pid}" )
+            raise(CmdException,"Run time of command \"#{@cmd_str}\" is over #{@vars[:cmd_timeout].to_s} sec. Fail to kill process : PID=#{pid}" )
           end
         end
       else
         status =  Process.waitpid2(pid)[1] >> 8
       end
       result = RBatch::CmdResult.new(stdout_file,stderr_file,status,@cmd_str)
-      if @opt[:cmd_raise] && status != 0
+      if @vars[:cmd_raise] && status != 0
         raise(CmdException,"Command exit status is not 0. result: " + result.to_s)
       end
       return result
@@ -117,13 +82,5 @@ module RBatch
     end
   end
 
-  class CmdException < Exception ; end
-
-  module_function
-
-  # shortcut of RBatch::Cmd
-  def cmd(cmd_str,opt = nil)
-    Cmd.new(cmd_str,opt).run
-  end
-
+  class CmdException < StandardError ; end
 end

data/lib/rbatch/config.rb

@@ -16,15 +16,15 @@ module RBatch
     end
     def[](key)
       if @hash.nil?
-        raise RBatch::Config::Exception, "Config file \"#{@path}\" does not exist"
+        raise RBatch::ConfigException, "Config file \"#{@path}\" does not exist"
       end
       if @hash[key].nil?
         if key.class == Symbol
-          raise RBatch::Config::Exception, "Value of key(:#{key} (Symbol)) is nil. By any chance, dou you mistake key class Symbol for String?"
+          raise RBatch::ConfigException, "Value of key(:#{key} (Symbol)) is nil. By any chance, dou you mistake key class Symbol for String?"
         elsif key.class == String
-          raise RBatch::Config::Exception, "Value of key(\"#{key}\" (String)) is nil"
+          raise RBatch::ConfigException, "Value of key(\"#{key}\" (String)) is nil"
         else
-          raise RBatch::Config::Exception, "Value of key(#{key}) is nil."
+          raise RBatch::ConfigException, "Value of key(#{key}) is nil."
         end
       else
         @hash[key]
@@ -34,20 +34,20 @@ module RBatch
     def exist? ; ! @hash.nil? ; end
     def to_h
       if @hash.nil?
-        raise RBatch::Config::Exception, "Config file \"#{@path}\" does not exist"
+        raise RBatch::ConfigException, "Config file \"#{@path}\" does not exist"
       else
         @hash
       end
     end
     def to_s
       if @hash.nil?
-        raise RBatch::Config::Exception, "Config file \"#{@path}\" does not exist"
+        raise RBatch::ConfigException, "Config file \"#{@path}\" does not exist"
       else
         @hash.to_s
       end
     end
   end
 
-  class RBatch::Config::Exception < Exception; end
+  class RBatch::ConfigException < StandardError ; end
 end
 

data/lib/rbatch/controller.rb

@@ -1,75 +1,51 @@
+require 'rbatch/variables'
+require 'rbatch/journal'
+require 'rbatch/run_conf'
+require 'rbatch/double_run_checker'
+require 'rbatch/log'
+require 'rbatch/config'
+require 'rbatch/cmd'
+
 module RBatch
   class Controller
-    @@journal_verbose_map = { :error => 1, :warn => 2, :info => 3, :debug => 4}
-    attr :program_name,:program_path
-    attr :home_dir,:log_dir,:conf_dir,:lib_dir
-    attr :run_conf_path, :run_conf
-    attr :config, :config_path
-    attr :common_config, :common_config_path
-    attr :journals,:logs
+    attr :vars,:config,:common_config,:journal,:user_logs
     def initialize
-      @journals = []
-      @logs = []
-      if ENV["RB_VERBOSE"]
-        @journal_verbose = ENV["RB_VERBOSE"].to_i
-      else
-        @journal_verbose = 3
-      end
-      @program_name = $PROGRAM_NAME
-      @program_base = File.basename($PROGRAM_NAME)
-      @program_path = File.expand_path(@program_name)
-      if  ENV["RB_HOME"]
-        @home_dir = File.expand_path(ENV["RB_HOME"])
-      else
-        @home_dir =  File.expand_path(File.join(File.dirname(@program_name) , ".."))
-      end
-      @run_conf_path = File.join(@home_dir,".rbatchrc")
-      @run_conf = RunConf.new(@run_conf_path,@home_dir)
-      journal :info, "=== START RBatch === (PID=#{$$.to_s})"
-      journal :debug,"RB_HOME : \"#{@home_dir}\""
-      journal :info, "Load Run-Conf: \"#{@run_conf_path}\""
-      journal :debug,"RBatch option : #{@run_conf.inspect}"
-      @lib_dir  = @run_conf[:lib_dir].gsub("<home>",@home_dir)
-      @conf_dir = @run_conf[:conf_dir].gsub("<home>",@home_dir)
-      @log_dir  = @run_conf[:log_dir].gsub("<home>",@home_dir)
-      # common config
-      @common_config_path = File.join(@conf_dir,@run_conf[:common_conf_name])
-      @common_config = RBatch::Config.new(@common_config_path)
-      journal :info, "Load Config  : \"#{@common_config_path}\"" if ! @common_config.nil?
-      # user config
-      @config_path = File.join(@conf_dir,Pathname(File.basename(@program_name)).sub_ext(".yaml").to_s)
-      @config = RBatch::Config.new(@config_path)
-      journal :info, "Load Config  : \"#{@config_path}\"" if ! @config.nil?
+      @vars = RBatch::Variables.new()
+      RBatch::Journal.def_vars = @vars
+      RBatch::Log.def_vars = @vars
+      RBatch::Cmd.def_vars = @vars
+      @journal = RBatch::Journal.new()
+      RBatch::Log.journal = @journal
+      @user_logs = []
+      @journal.put 1,"=== START RBatch === (PID=#{$$.to_s})"
+      @journal.put 1, "RB_HOME : \"#{@vars[:home_dir]}\""
+      @journal.put 1, "Load Run-Conf: \"#{@vars[:run_conf_path]}\""
+      @journal.put 2, "RBatch Variables : #{@vars.inspect}"
+      @common_config = RBatch::Config.new(@vars[:common_config_path])
+      @journal.put 1, "Load Config  : \"#{@vars[:common_config_path]}\"" if ! @common_config.nil?
+      @config = RBatch::Config.new(@vars[:config_path])
+      @journal.put 1, "Load Config  : \"#{@vars[:config_path]}\"" if ! @config.nil?
+
       # double_run_check
-      if ( @run_conf[:forbid_double_run] )
-        RBatch::DoubleRunChecker.check(@program_base) #raise error if check is NG
-        RBatch::DoubleRunChecker.make_lock_file(@program_base)
+      if ( @vars[:forbid_double_run])
+        RBatch::DoubleRunChecker.check(@pvars[:rogram_base]) #raise error if check is NG
+        RBatch::DoubleRunChecker.make_lock_file(@vars[:program_base])
       end
       # load_lib
-      if @run_conf[:auto_lib_load] && Dir.exist?(@lib_dir)
-        Dir::foreach(@lib_dir) do |file|
+      if @vars[:auto_lib_load] && Dir.exist?(@vars[:lib_dir])
+        Dir::foreach(@vars[:lib_dir]) do |file|
           if /.*rb/ =~ file
-            require File.join(@lib_dir,File.basename(file,".rb"))
-            journal :info, "Load Library : \"#{File.join(@lib_dir,file)}\" "
+            require File.join(@vars[:lib_dir],File.basename(file,".rb"))
+            @journal.put 1, "Load Library : \"#{File.join(@vars[:lib_dir],file)}\" "
           end
         end
       end
-      journal :info,"Start Script : \"#{@program_path}\""
+      @journal.put 1, "Start Script : \"#{@vars[:program_path]}\""
     end #end def
-    def journal(level,str)
-      if @@journal_verbose_map[level] <= @journal_verbose
-        str = "[RBatch] " + str
-        puts str
-        @journals << str
-        @logs.each do |log|
-          if RBatch.run_conf[:mix_rbatch_msg_to_log]
-            log.journal(str)
-          end
-        end
-      end
-    end
-    def add_log(log)
-      @logs << log
+    def config ; @config ; end
+    def common_config ; @common_config ; end
+    def cmd(cmd_str,opt)
+      RBatch::Cmd.new(cmd_str,opt).run
     end
   end
 end

data/lib/rbatch/journal.rb

@@ -0,0 +1,40 @@
+module RBatch
+  class Journal
+    @@def_vars
+    def Journal.def_vars=(a) ; @@def_vars=a ; end 
+    attr :journals,:journal_verbose,:user_logs
+    def initialize(verbose=nil)
+      if verbose.nil?
+        if ENV["RB_VERBOSE"]
+          @journal_verbose = ENV["RB_VERBOSE"].to_i
+        else
+          @journal_verbose = 1
+        end
+      else
+        @journal_verbose = verbose
+      end
+      @journals = []
+      @user_logs = []
+    end
+    def put(level,str)
+      if level <= @journal_verbose
+        @journals << str
+        str = "[RBatch] " + str
+        puts str
+        @user_logs.each do |log|
+          if @@def_vars[:mix_rbatch_journal_to_logs]
+            log.journal(str)
+          end
+        end
+      end
+    end
+    def add_log(log)
+      @user_logs << log
+      if @@def_vars[:mix_rbatch_journal_to_logs]
+        @journals.each do |j|
+          log.journal(j)
+        end
+      end
+    end
+  end
+end

data/lib/rbatch/log.rb

@@ -3,140 +3,82 @@ require 'fileutils'
 require 'pathname'
 require 'net/smtp'
 
+
 module RBatch
-  #=== About RBatch::Log
-  #
-  #By using Logging block, RBatch writes to logfile automatically.
-  #
-  #The default location of log file is "${RB_HOME}/log/YYYYMMDD_HHMMSS_(program base name).log" .
-  #
-  #If an exception occuerd, then RBatch writes back trace to logfile.
-  #
-  #=== Sample
-  #
-  #script : ${RB_HOME}/bin/sample1.rb
-  #
-  # require 'rbatch'
-  # 
-  # RBatch::Log.new(){ |log|  # Logging block
-  #   log.info "info string"
-  #   log.error "error string"
-  #   raise "exception"
-  # }
-  #
-  #
-  #logfile : ${RB_HOME}/log/20121020_005953_sample1.log
-  #
-  # [2012-10-20 00:59:53 +900] [INFO ] info string
-  # [2012-10-20 00:59:53 +900] [ERROR] error string
-  # [2012-10-20 00:59:53 +900] [FATAL] Caught exception; existing 1
-  # [2012-10-20 00:59:53 +900] [FATAL] exception (RuntimeError)
-  #     [backtrace] test.rb:6:in `block in <main>'
-  #     [backtrace] /usr/local/lib/ruby192/lib/ruby/gems/1.9.1/gems/rbatch-1.0.0/lib/rbatch/auto_logger.rb:37:in `initialize'
-  #     [backtrace] test.rb:3:in `new'
-  #     [backtrace] test.rb:3:in `<main>'
-  #
   class Log
-    @@verbose = false
-    @@log_level_map = {
+    @@FORMATTER = proc do |severity, datetime, progname, msg|
+      head = "[#{datetime}] [" + sprintf("%-5s",severity) +"]"
+      if msg.is_a? Exception
+        "#{head} #{msg}\n" + msg.backtrace.map{|s| "    [backtrace] #{s}"}.join("\n") + "\n"
+      else
+        "#{head} #{msg}\n"
+      end
+    end
+    @@STDOUT_FORMATTER = proc do |severity, datetime, progname, msg|
+      head = "[" + sprintf("%-5s",severity) +"]"
+      if msg.is_a? Exception
+        "#{head} #{msg}\n" + msg.backtrace.map{|s| "    [backtrace] #{s}"}.join("\n") + "\n"
+      else
+        "#{head} #{msg}\n"
+      end
+    end
+    @@LOG_LEVEL_MAP = {
       "debug" => Logger::DEBUG,
       "info"  => Logger::INFO,
       "warn"  => Logger::WARN,
       "error" => Logger::ERROR,
       "fatal" => Logger::FATAL
     }
-
-    @opt # option
-    @log # log instance for file
-    @stdout_log # log instance for STDOUT
-    @prog_base # program file name base
-    @file_name # log file name
-
-    # Set verbose mode flag.
-    def Log.verbose=(bol); @@verbose = bol ; end
-
-    # Get verbose mode flag.
-    def Log.verbose ; @@verbose ; end
-
-    # Get Option
-    def opt; @opt ; end
-
-    # Logging Block.
-    # 
-    # ==== Params
-    # +opt+ = Option hash object.
-    # - +:name+ (String) = name of log file. Default is "<date>_<time>_<prog>.log". Reservation-words are "<date>","<time>","<prog>","<host>". "<date>" is replaced YYYYMMDD. "<time>" is replaced HHMMSS. "<prog>" is replaced a base-name of program file.
-    # - +:dir+ (String) = log direcotry. Default is "${RB_HOME}/log"
-    # - +:level+ (String) = log level. Default is "info". ["debug"|"info"|"warn"|"error"|"fatal"] .
-    # - +:append+ (Boolean) = appned to log or not(=overwrite). Default is ture.
-    # - +:stdout+ (Boolean) = output both the log file and STDOUT. Default is false.
-    # ==== Block params
-    # +log+ = Instance of +Logger+
-    # ==== Sample
-    #  RBatch::Log.new({:dir => "/tmp", :level => "info"}){ |log|
-    #    log.info "info string"
-    #  }
-    #
-    def initialize(opt = nil)
-      # parse option
-      tmp = {}
-      if opt.nil?
-        @opt=RBatch.run_conf.clone
-      else
+    @@def_vars
+    def Log.def_vars=(a)
+      raise ArgumentError, "type mismatch: #{a} for #RBatch::Variables" if ! a.kind_of?(RBatch::Variables)
+      @@def_vars=a
+    end
+    def Log.def_vars    ; @@def_vars ; end
+    @@journal
+    def Log.journal=(a) ; @@journal=a ; end
+
+    @vars
+    @opt
+    @log
+    @stdout_log
+
+    def initialize(opt=nil)
+      @opt = opt
+      @vars = @@def_vars.clone
+      if ! opt.nil?
+        # change opt key from "hoge" to "log_hoge"
+        tmp = {}
         opt.each_key do |key|
           tmp[("log_" + key.to_s).to_sym] = opt[key]
         end
-        @opt=RBatch.run_conf.merge(tmp)
+        @vars.merge!(tmp)
       end
-
-      # determine log file name
-      @prog_base = Pathname(File.basename(RBatch.ctrl.program_name)).sub_ext("").to_s
-      @file_name = @opt[:log_name].clone
-      @file_name.gsub!("<date>", Time.now.strftime("%Y%m%d"))
-      @file_name.gsub!("<time>", Time.now.strftime("%H%M%S"))
-      @file_name.gsub!("<prog>", @prog_base)
-      @file_name.gsub!("<host>", @opt[:log_hostname])
-      @log_dir = @opt[:log_dir].gsub("<home>",RBatch.ctrl.home_dir)
-      path = File.join(@log_dir,@file_name)
+      @path = File.join(@vars[:log_dir],@vars[:log_name])
       # create Logger instance
       begin
-        if @opt[:log_append] && File.exist?(path)
-          @log = Logger.new(open(path,"a"))
+        if @vars[:log_append] && File.exist?(@path)
+          @log = Logger.new(open(@path,"a"))
         else
-          @log = Logger.new(open(path,"w"))
+          @log = Logger.new(open(@path,"w"))
         end
       rescue Errno::ENOENT => e
-        RBatch.ctrl.journal :error, "Can not open log file  - #{path}"
-        raise e
+        raise LogException,"Can not open log file  - #{@path}"
       end
       # set logger option
-      formatter = proc do |severity, datetime, progname, msg|
-        head = "[#{datetime}] [" + sprintf("%-5s",severity) +"]"
-        if msg.is_a? Exception
-          "#{head} #{msg}\n" + msg.backtrace.map{|s| "    [backtrace] #{s}"}.join("\n") + "\n"
-        else
-          "#{head} #{msg}\n"
-        end
-      end
-      @log.level = @@log_level_map[@opt[:log_level]]
-      @log.formatter = formatter
-      if @opt[:log_stdout]
+      @log.level = @@LOG_LEVEL_MAP[@vars[:log_level]]
+      @log.formatter = @@FORMATTER
+      if @vars[:log_stdout]
         # ccreate Logger instance for STDOUT
         @stdout_log = Logger.new(STDOUT)
-        @stdout_log.level = @@log_level_map[@opt[:log_level]]
-        @stdout_log.formatter = formatter
+        @stdout_log.level = @@LOG_LEVEL_MAP[@vars[:log_level]]
+        @stdout_log.formatter = @@STDOUT_FORMATTER
       end
-      RBatch.ctrl.journal :info,"Start Logging: \"#{path}\""
       # delete old log
-      self.delete_old_log(@opt[:log_delete_old_log_date]) if @opt[:log_delete_old_log]
-      # Firstly write journal to log
-      if RBatch.run_conf[:mix_rbatch_msg_to_log]
-        RBatch.ctrl.journals.each do |str|
-          self.journal(str)
-        end
-        RBatch.ctrl.add_log(self)
-      end
+      self.delete_old_log(@vars[:log_delete_old_log_date]) if @vars[:log_delete_old_log]
       # Start logging
+      @@journal.put 1,"Logging Start: \"#{@path}\""
+      @@journal.add_log(self)
       if block_given?
         begin
           yield self
@@ -151,29 +93,29 @@ module RBatch
     end
 
     def fatal(a)
-      @stdout_log.fatal(a) if @opt[:log_stdout]
+      @stdout_log.fatal(a) if @vars[:log_stdout]
       @log.fatal(a)
-      send_mail(a) if @opt[:log_send_mail]
+      send_mail(a) if @vars[:log_send_mail]
     end
 
     def error(a)
-      @stdout_log.error(a) if @opt[:log_stdout]
+      @stdout_log.error(a) if @vars[:log_stdout]
       @log.error(a)
-      send_mail(a) if @opt[:log_send_mail]
+      send_mail(a) if @vars[:log_send_mail]
     end
 
     def warn(a)
-      @stdout_log.warn(a) if @opt[:log_stdout]
+      @stdout_log.warn(a) if @vars[:log_stdout]
       @log.warn(a)
     end
 
     def info(a)
-      @stdout_log.info(a) if @opt[:log_stdout]
+      @stdout_log.info(a) if @vars[:log_stdout]
       @log.info(a)
     end
 
     def debug(a)
-      @stdout_log.debug(a) if @opt[:log_stdout]
+      @stdout_log.debug(a) if @vars[:log_stdout]
       @log.debug(a)
     end
 
@@ -182,27 +124,26 @@ module RBatch
     end
 
     def close
-      @stdout_log.close if @opt[:log_stdout]
       @log.close
     end
 
     # Delete old log files.
-    # If @opt[:log_name] is not include "<date>", then do nothing.
+    # If @vars[:log_name] is not include "<date>", then do nothing.
     #
     # ==== Params
     # - +date+ (Integer): The day of leaving log files
     #
     def delete_old_log(date = 7)
-      if Dir.exists?(@log_dir) && @opt[:log_name].include?("<date>")
-        Dir::foreach(@log_dir) do |file|
+      if Dir.exists?(@vars[:log_dir]) && @vars.raw_value(:log_name).include?("<date>")
+        Dir::foreach(@vars[:log_dir]) do |file|
           r = Regexp.new("^" \
-                         + @opt[:log_name].gsub("<prog>",@prog_base)\
+                         + @vars.raw_value(:log_name).gsub("<prog>",@vars[:program_base])\
                            .gsub("<time>","[0-2][0-9][0-5][0-9][0-5][0-9]")\
                            .gsub("<date>","([0-9][0-9][0-9][0-9][0-1][0-9][0-3][0-9])")\
                          + "$")
           if r =~ file && Date.strptime($1,"%Y%m%d") <= Date.today - date
-            RBatch.journal :info, "Delete old log file: " + File.join(@log_dir , file)
-            File::delete(File.join(@log_dir  , file))
+            @@journal.put 1, "Delete old log file: " + File.join(@vars[:log_dir] , file)
+            File::delete(File.join(@vars[:log_dir]  , file))
           end
         end
       end
@@ -213,9 +154,9 @@ module RBatch
     # send mail
     def send_mail(msg)
       body = <<EOT
-From: <#{@opt[:log_mail_from]}>
-To: <#{@opt[:log_mail_to]}>
-Subject: [RBatch] #{RBatch.ctrl.program_name} has error
+From: <#{@vars[:log_mail_from]}>
+To: <#{@vars[:log_mail_to]}>
+Subject: [RBatch] #{@vars[:program_name]} has error
 Date: #{Time::now.strftime("%a, %d %b %Y %X %z")}
 Mime-Version: 1.0
 Content-Type: text/plain; charset=ISO-2022-JP
@@ -223,10 +164,11 @@ Content-Transfer-Encoding: 7bit
 
 #{msg}
 EOT
-      Net::SMTP.start(@opt[:log_mail_server_host],@opt[:log_mail_server_port] ) {|smtp|
-        smtp.send_mail(body,@opt[:log_mail_from],@opt[:log_mail_to])
+      Net::SMTP.start(@vars[:log_mail_server_host],@vars[:log_mail_server_port] ) {|smtp|
+        smtp.send_mail(body,@vars[:log_mail_from],@vars[:log_mail_to])
       }
     end
   end # end class
+  class LogException < StandardError ; end
 end # end module
 

data/lib/rbatch/run_conf.rb

@@ -2,9 +2,8 @@ require 'tmpdir'
 require 'yaml'
 module RBatch
   class RunConf
-    @opt
+    attr :path,:opt
     @yaml
-    attr_reader :run_conf_path,:home_dir
     @@def_opt = {
       :conf_dir      => "<home>/conf",
       :common_conf_name => "common.yaml",
@@ -21,35 +20,26 @@ module RBatch
       :log_delete_old_log => false,
       :log_delete_old_log_date => 7,
       :log_send_mail => false,
-      :log_hostname => "unknownhost",
       :log_mail_to   => nil,
       :log_mail_from => "rbatch.localhost",
       :log_mail_server_host => "localhost",
       :log_mail_server_port => 25,
-      :mix_rbatch_msg_to_log => true
+      :rbatch_journal_level => 1,
+      :mix_rbatch_journal_to_logs => true
     }
-    def initialize(run_conf_path,home_dir)
-      @run_conf_path = run_conf_path
-      @home_dir = home_dir
-      reset
-      load
-    end
-
-    def reset()
-      @opt = @@def_opt.clone
-      case RUBY_PLATFORM
-      when /mswin|mingw/
-        @opt[:log_hostname] =  ENV["COMPUTERNAME"] ? ENV["COMPUTERNAME"] : "unknownhost"
-      when /cygwin|linux/
-        @opt[:log_hostname] = ENV["HOSTNAME"] ? ENV["HOSTNAME"] : "unknownhost"
+    def initialize(path=nil)
+      if path.nil?
+        @opt = @@def_opt.clone
       else
-        @opt[:log_hostname] = "unknownhost"
+        @path = path
+        @opt = @@def_opt.clone
+        load
       end
     end
 
     def load()
       begin
-        @yaml = YAML::load_file(@run_conf_path)
+        @yaml = YAML::load_file(@path)
       rescue
         # when run_conf does not exist, do nothing.
         @yaml = false
@@ -65,11 +55,10 @@ module RBatch
       end
     end
 
-    def reload()
-      reset
-      load
+    def has_key?(key)
+      @opt.has_key?(key)
     end
-
+    
     def merge!(opt)
       opt.each_key do |key|
         if @opt.has_key?(key)