rbatch 1.13.1 → 2.0.0

data/lib/rbatch/log.rb

@@ -38,21 +38,6 @@ module RBatch
   #
   class Log
     @@verbose = false
-    @@def_opt = {
-      :name      => "<date>_<time>_<prog>.log",
-      :dir       => File.join(RBatch::home_dir , "log"),
-      :append    => true,
-      :level     => "info",
-      :stdout    => false,
-      :quiet     => false,
-      :delete_old_log => false,
-      :delete_old_log_date => 7,
-      :send_mail => false,
-      :mail_to   => nil,
-      :mail_from => "rbatch.localhost",
-      :mail_server_host => "localhost",
-      :mail_server_port => 25
-    }
     @@log_level_map = {
       "debug" => Logger::DEBUG,
       "info"  => Logger::INFO,
@@ -85,7 +70,6 @@ module RBatch
     # - +: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.
-    # - +:quiet+ (Boolean) = output only logfile, don't output to STDOUT.  Default is true.
     # ==== Block params
     # +log+ = Instance of +Logger+
     # ==== Sample
@@ -95,37 +79,34 @@ module RBatch
     #
     def initialize(opt = nil)
       # parse option
-      @opt = @@def_opt.clone
-      @@def_opt.each_key do |key|
-        if opt != nil  && opt[key] != nil
-          # use argument
-          @opt[key] = opt[key]
-        elsif RBatch.rbatch_config != nil \
-          && RBatch.rbatch_config["log_" + key.to_s] != nil
-          # use config
-          @opt[key] = RBatch.rbatch_config["log_" + key.to_s]
-        else
-          # use default
+      tmp = {}
+      if opt.nil?
+        @opt=RBatch.run_conf.clone
+      else
+        opt.each_key do |key|
+          tmp[("log_" + key.to_s).to_sym] = opt[key]
         end
+        @opt=RBatch.run_conf.merge(tmp)
       end
-      puts "option = " + @opt.to_s if @@verbose
+
       # determine log file name
       @prog_base = Pathname(File.basename(RBatch.program_name)).sub_ext("").to_s
-      @file_name = @opt[:name].clone
+      @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>", RBatch::hostname)
-      path = File.join(@opt[:dir],@file_name)
+      @file_name.gsub!("<host>", @opt[:log_hostname])
+      @log_dir = @opt[:log_dir].gsub("<home>",RBatch.home_dir)
+      path = File.join(@log_dir,@file_name)
       # create Logger instance
       begin
-        if @opt[:append] && File.exist?(path)
+        if @opt[:log_append] && File.exist?(path)
           @log = Logger.new(open(path,"a"))
         else
           @log = Logger.new(open(path,"w"))
         end
       rescue Errno::ENOENT => e
-        STDERR.puts "RBatch ERROR: Can not open log file  - #{path}" if ! @opt[:quiet]
+        RBatch.journal :error, "Can not open log file  - #{path}"
         raise e
       end
       # set logger option
@@ -137,21 +118,18 @@ module RBatch
           "#{head} #{msg}\n"
         end
       end
-      @log.formatter = @opt[:formatter] if @opt[:formatter]
-      @log.level = @@log_level_map[@opt[:level]]
+      @log.level = @@log_level_map[@opt[:log_level]]
       @log.formatter = formatter
-      if @opt[:stdout]
+      if @opt[:log_stdout]
         # ccreate Logger instance for STDOUT
         @stdout_log = Logger.new(STDOUT)
-        @stdout_log.formatter = @opt[:formatter] if @opt[:formatter]
-        @stdout_log.level = @@log_level_map[@opt[:level]]
+        @stdout_log.level = @@log_level_map[@opt[:log_level]]
         @stdout_log.formatter = formatter
       end
-      puts "Log file: " + path if ! @opt[:quiet]
+      RBatch.journal :info,"Start Logging. Log file: " + path
       # delete old log
-      self.delete_old_log(@opt[:delete_old_log_date]) if @opt[:delete_old_log]
+      self.delete_old_log(@opt[:log_delete_old_log_date]) if @opt[:log_delete_old_log]
       # Start logging
-      self.info("Start Logging. (PID=#{$$.to_s})") if ! @opt[:quiet]
       if block_given?
         begin
           yield self
@@ -166,54 +144,54 @@ module RBatch
     end
 
     def fatal(a)
-      @stdout_log.fatal(a) if @opt[:stdout]
+      @stdout_log.fatal(a) if @opt[:log_stdout]
       @log.fatal(a)
-      send_mail(a) if @opt[:send_mail]
+      send_mail(a) if @opt[:log_send_mail]
     end
 
     def error(a)
-      @stdout_log.error(a) if @opt[:stdout]
+      @stdout_log.error(a) if @opt[:log_stdout]
       @log.error(a)
-      send_mail(a) if @opt[:send_mail]
+      send_mail(a) if @opt[:log_send_mail]
     end
 
     def warn(a)
-      @stdout_log.warn(a) if @opt[:stdout]
+      @stdout_log.warn(a) if @opt[:log_stdout]
       @log.warn(a)
     end
 
     def info(a)
-      @stdout_log.info(a) if @opt[:stdout]
+      @stdout_log.info(a) if @opt[:log_stdout]
       @log.info(a)
     end
 
     def debug(a)
-      @stdout_log.debug(a) if @opt[:stdout]
+      @stdout_log.debug(a) if @opt[:log_stdout]
       @log.debug(a)
     end
 
     def close
-      @stdout_log.close if @opt[:stdout]
+      @stdout_log.close if @opt[:log_stdout]
       @log.close
     end
 
     # Delete old log files.
-    # If @opt[:name] is not include "<date>", then do nothing.
+    # If @opt[: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?(@opt[:dir]) && @opt[:name].include?("<date>")
-        Dir::foreach(@opt[:dir]) do |file|
+      if Dir.exists?(@log_dir) && @opt[:log_name].include?("<date>")
+        Dir::foreach(@log_dir) do |file|
           r = Regexp.new("^" \
-                         + @opt[:name].gsub("<prog>",@prog_base)\
+                         + @opt[:log_name].gsub("<prog>",@prog_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
-            puts "Delete old log file: " + File.join(@opt[:dir] , file) if ! @opt[:quiet]
-            File::delete(File.join(@opt[:dir]  , file))
+            RBatch.journal :info, "Delete old log file: " + File.join(@log_dir , file)
+            File::delete(File.join(@log_dir  , file))
           end
         end
       end
@@ -224,8 +202,8 @@ module RBatch
     # send mail
     def send_mail(msg)
       body = <<EOT
-From: <#{@opt[:mail_from]}>
-To: <#{@opt[:mail_to]}>
+From: <#{@opt[:log_mail_from]}>
+To: <#{@opt[:log_mail_to]}>
 Subject: [RBatch] #{RBatch.program_name} has error
 Date: #{Time::now.strftime("%a, %d %b %Y %X %z")}
 Mime-Version: 1.0
@@ -234,8 +212,8 @@ Content-Transfer-Encoding: 7bit
 
 #{msg}
 EOT
-      Net::SMTP.start(@opt[:mail_server_host],@opt[:mail_server_port] ) {|smtp|
-        smtp.send_mail(body,@opt[:mail_from],@opt[:mail_to])
+      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])
       }
     end
   end # end class

data/lib/rbatch/run_conf.rb

@@ -0,0 +1,109 @@
+require 'tmpdir'
+require 'yaml'
+module RBatch
+  class RunConf
+    @opt
+    @yaml
+    attr_reader :run_conf_path,:home_dir
+    @@def_opt = {
+      :conf_dir      => "<home>/conf",
+      :common_conf_name => "common.yaml",
+      :forbid_double_run => false,
+      :cmd_raise     => false,
+      :cmd_timeout   => 0,
+      :log_dir       => "<home>/log",
+      :log_name      => "<date>_<time>_<prog>.log",
+      :log_append    => true,
+      :log_level     => "info",
+      :log_stdout    => false,
+      :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
+    }
+    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"
+      else
+        @opt[:log_hostname] = "unknownhost"
+      end
+    end
+
+    def load()
+      begin
+        @yaml = YAML::load_file(@run_conf_path)
+      rescue
+        # when run_conf does not exist, do nothing.
+        @yaml = false
+      end
+      if @yaml
+        @yaml.each_key do |key|
+          if @@def_opt.has_key?(key.to_sym)
+            @opt[key.to_sym]=@yaml[key]
+          else
+            raise RBatch::RunConf::Exception, "\"#{key}\" is not available option"
+          end
+        end
+      end
+    end
+
+    def reload()
+      reset
+      load
+    end
+
+    def merge!(opt)
+      opt.each_key do |key|
+        if @opt.has_key?(key)
+          @opt[key] = opt[key]
+        else
+          raise RBatch::RunConf::Exception, "\"#{key}\" is not available option"
+        end
+      end
+    end
+
+    def merge(opt)
+      tmp = @opt.clone
+      opt.each_key do |key|
+        if tmp.has_key?(key)
+          tmp[key] = opt[key]
+        else
+          raise RBatch::RunConf::Exception, "\"#{key}\" is not available option"
+        end
+      end
+      return tmp
+    end
+
+    def[](key)
+      if @opt[key].nil?
+        raise RBatch::RunConf::Exception, "Value of key=\"#{key}\" is nil"
+      end
+      @opt[key]
+    end
+
+    def[]=(key,value)
+      if ! @opt.has_key?(key)
+        raise RBatch::RunConf::Exception, "Key=\"#{key}\" does not exist"
+      end
+      @opt[key]=value
+    end
+  end
+
+  class RunConf::Exception < Exception ; end
+
+end

data/lib/rbatch/version.rb

@@ -1,3 +1,3 @@
 module RBatch
-  VERSION = "1.13.1"
+  VERSION = "2.0.0"
 end

data/lib/rbatch.rb

@@ -1,74 +1,55 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
-require 'digest'
 require 'yaml'
+
 module RBatch
-  @@opt = {}
-  @@rbatch_config = nil
+  @@program_name = $PROGRAM_NAME
+  @@program_base = File.basename($PROGRAM_NAME)
+  @@home_dir = nil
+  @@run_conf_path = nil
+  @@run_conf = nil
+  @@journal_verbose = 3
+  @@journal_verbose_map = { :error => 1, :warn => 2, :info => 3, :debug => 4}
   module_function
-  def program_name       ; @@opt[:program_name] ; end
-  def home_dir           ; @@opt[:home_dir] ; end
-  def home_dir=(d)       ; @@opt[:home_dir]=d ; end
-  def hostname           ; @@opt[:hostname] ; end
-  def rbatch_config      ; @@rbatch_config ; end
-  def opt                ; @@opt ; end
-  def init
-    @@opt[:program_name] = $PROGRAM_NAME
-    @@opt[:home_dir] = ENV["RB_HOME"] ? ENV["RB_HOME"] : File.join(File.dirname(@@opt[:program_name]) , "..")
-    case RUBY_PLATFORM
-    when /mswin|mingw/
-      @@opt[:hostname] =  ENV["COMPUTERNAME"] ? ENV["COMPUTERNAME"] : "unknownhost"
-    when /cygwin|linux/
-      @@opt[:hostname] = ENV["HOSTNAME"] ? ENV["HOSTNAME"] : "unknownhost"
-    else
-      @@opt[:hostname] = "unknownhost"
-    end
-    load_rbatch_config
-  end
-  def rbatch_config_path
-    File.join(@@opt[:home_dir],"conf","rbatch.yaml")
-  end
-  def config_dir
-    File.join(RBatch.home_dir,"conf")
-  end
-  def log_dir
-    File.join(RBatch.home_dir,"log")
+  def program_name  ; @@program_name ; end
+  def program_base  ; @@program_base ; end
+  def home_dir      ; @@home_dir ; end
+  def run_conf_path ; @@run_conf_path ; end
+  def run_conf      ; @@run_conf ; end
+  def conf_dir      ; @@run_conf[:conf_dir].gsub("<home>",@@home_dir) ; end
+  def log_dir       ; @@run_conf[:log_dir].gsub("<home>",@@home_dir) ; end
+  def journal(level,str)
+    puts "[RBatch] " + str if @@journal_verbose_map[level] <= @@journal_verbose
   end
-  def load_rbatch_config
-    if File.exist?(rbatch_config_path)
-      @@rbatch_config = YAML::load_file(rbatch_config_path)
-      if @@rbatch_config == false
-        @@rbatch_config = nil
-      end
+  def init
+    @@journal_verbose = ENV["RB_VERBOSE"].to_i if ENV["RB_VERBOSE"]
+    if  ENV["RB_HOME"]
+      @@home_dir = ENV["RB_HOME"]
+      RBatch.journal :info,"RB_HOME : \"#{@@home_dir}\" (defined by $RB_HOME)"
     else
-      @@rbatch_config = nil
-    end
-  end
-  def double_run_check
-    # double run check
-    if ( @@rbatch_config != nil && @@rbatch_config["forbid_double_run"] )
-      lock_file="rbatch_lock_" + Digest::MD5.hexdigest(@@opt[:program_name])
-      if Dir.exists? @@opt[:tmp_dir]
-        Dir::foreach(@@opt[:tmp_dir]) do |f|
-          if (Regexp.new(lock_file) =~ f)
-            raise RBatchException, "Script double run is forbid about \"#{@@opt[:program_name]}\""
-          end
-        end
-      end
-      # make lockfile
-      Tempfile::new(lock_file,@@opt[:tmp_dir])
+      @@home_dir =  File.join(File.dirname(@@program_name) , "..")
+      RBatch.journal :info,"RB_HOME : \"#{@@home_dir}\" (default)"
     end
+    @@run_conf_path = File.join(@@home_dir,".rbatchrc")
+    RBatch.journal :info,"Run-Conf: \"#{@@run_conf_path}\""
+
+    @@run_conf = RunConf.new(@@run_conf_path,@@home_dir)
+    RBatch.journal :debug,"RBatch option : #{@@run_conf.inspect}"
   end
 end
 
-# RBatch Exception
-class RBatchException < Exception ; end
-
 # main
+require 'rbatch/run_conf'
+require 'rbatch/double_run_checker'
+
 RBatch::init
+if ( RBatch.run_conf[:forbid_double_run] )
+  RBatch::DoubleRunChecker.check(File.basename(RBatch.program_name)) #raise error if check is NG
+  RBatch::DoubleRunChecker.make_lock_file(File.basename(RBatch.program_name))
+end
 
 require 'rbatch/log'
 require 'rbatch/config'
 require 'rbatch/common_config'
 require 'rbatch/cmd'
 
-RBatch::double_run_check
+RBatch.journal :info,"Start \"#{RBatch.program_name}\" under RBatch (PID=#{$$.to_s})"

data/spec/{cmd_test.spec → cmd_spec.rb}

@@ -1,9 +1,13 @@
 require 'tmpdir'
+ENV["RB_VERBOSE"]="0"
 ENV["RB_HOME"]=Dir.tmpdir
 
 require 'rbatch'
 
 describe RBatch::Cmd do
+  before :each do
+    RBatch.run_conf.reset
+  end
 
   it "run command which status is 0" do
     result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'"
@@ -110,18 +114,14 @@ describe RBatch::Cmd do
       Dir::mkdir @config_dir if ! Dir.exists? @config_dir
     end
     describe "raise" do
-      before :all do
-        open( @config_file  , "w" ){|f| f.write("cmd_raise: true")}
-        RBatch.load_rbatch_config
+      before :each do
+        RBatch.run_conf[:cmd_raise] = true
       end
       it "raise error when command status is not 0" do
         expect {
           RBatch::cmd "ruby -e 'exit 1;'"
         }.to raise_error(RBatch::CmdException)
       end
-      after :each do
-        FileUtils.rm @config_file
-      end
     end
   end
 end

data/spec/common_config_spec.rb

@@ -0,0 +1,54 @@
+require 'tmpdir'
+ENV["RB_VERBOSE"]="0"
+ENV["RB_HOME"]=Dir.tmpdir
+
+require 'rbatch'
+
+describe RBatch::CommonConfig do
+  before :all do
+    @config_dir=File.join(Dir.tmpdir,"conf")
+    @config_file = File.join(@config_dir , "common.yaml")
+    Dir::mkdir @config_dir if ! Dir.exists? @config_dir
+  end
+
+  before :each do
+  end
+
+  after :each do
+    FileUtils.rm @config_file if File.exists? @config_file
+  end
+
+  after :all do
+  end
+
+  it "read config" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect(RBatch.common_config["key"]).to eq "value"
+  end
+
+  it "raise error when config does not exist" do
+    expect {
+      RBatch.common_config
+    }.to raise_error(Errno::ENOENT)
+  end
+
+  it "read config twice" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect(RBatch.common_config["key"]).to eq "value"
+    expect(RBatch.common_config["key"]).to eq "value"
+  end
+
+  it "raise error when read value which key does not exist" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect {
+      RBatch.common_config["not_exist"]
+    }.to raise_error(RBatch::CommonConfig::Exception)
+  end
+
+  it "success when common_conf_name changed" do
+    conf=File.join(Dir.tmpdir,"global.yaml")
+    open( conf  , "w" ){|f| f.write("key4: value4")}
+    RBatch.run_conf[:common_conf_name]="global.yaml"
+    expect(RBatch.common_config["key4"]).to eq "value4"
+  end
+end

data/spec/{config_test.spec → config_spec.rb}

@@ -1,11 +1,12 @@
 require 'tmpdir'
+ENV["RB_VERBOSE"]="0"
 ENV["RB_HOME"]=Dir.tmpdir
 
 require 'rbatch'
 
 describe RBatch::Config do
   before :all do
-    @config_dir=RBatch.config_dir
+    @config_dir=File.join(Dir.tmpdir,"conf")
     @config_file = File.join(@config_dir , "rspec.yaml")
     Dir::mkdir @config_dir if ! Dir.exists? @config_dir
   end

data/spec/double_run_checker_spec.rb

@@ -0,0 +1,10 @@
+require 'rbatch/double_run_checker'
+
+describe RBatch::DoubleRunChecker do
+  it "check" do
+    expect{RBatch::DoubleRunChecker.check("hoge")}.to_not raise_error
+    RBatch::DoubleRunChecker.make_lock_file("hoge")
+    expect{RBatch::DoubleRunChecker.check("hoge")}.to raise_error(RBatch::DoubleRunCheckException)
+    expect{RBatch::DoubleRunChecker.check("bar")}.to_not raise_error
+  end
+end

data/spec/{log_test.spec → log_spec.rb}

@@ -1,4 +1,5 @@
 require 'tmpdir'
+ENV["RB_VERBOSE"]="0"
 ENV["RB_HOME"]=Dir.tmpdir
 
 require 'rbatch'
@@ -6,21 +7,20 @@ require 'rbatch'
 describe RBatch::Log do
 
   before :all do
-    @dir = RBatch.log_dir
+    @dir = File.join(Dir.tmpdir,"log")
     Dir::mkdir(@dir)if ! Dir.exists? @dir
   end
 
   before :each do
-    # set quiet option
-    confstr = "log_quiet: true\n"
-    open( RBatch.rbatch_config_path  , "w" ){|f| f.write(confstr)}
-    RBatch.load_rbatch_config
+    open( RBatch.run_conf_path  , "w" ){|f| f.write("")}
+    RBatch.run_conf.reload
   end
 
   after :each do
     Dir::foreach(@dir) do |f|
       File::delete(File.join(@dir , f)) if ! (/\.+$/ =~ f)
     end
+    FileUtils.rm(RBatch.run_conf_path) if File.exist?(RBatch.run_conf_path)
   end
 
   it "is run" do
@@ -271,8 +271,8 @@ describe RBatch::Log do
   describe "option by config" do
     it "change log name" do
       confstr = "log_name: name1.log"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new() do | log |
         log.info("hoge")
       end
@@ -284,8 +284,8 @@ describe RBatch::Log do
     it "change log dir" do
       @tmp = Dir.tmpdir
       confstr = "log_name: c.log\nlog_dir: " + @tmp
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new({:name => "c.log", :dir=> @tmp }) do | log |
         log.info("hoge")
       end
@@ -295,9 +295,9 @@ describe RBatch::Log do
     end
 
     it "is append mode" do
-      confstr = "log_name: a.log\nappend: true"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      confstr = "log_name: a.log\nlog_append: true"
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new() do | log |
         log.info("line1")
       end
@@ -313,8 +313,8 @@ describe RBatch::Log do
 
     it "is overwrite mode" do
       confstr = "log_name: a.log\nlog_append: false"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new() do | log |
         log.info("line1")
       end
@@ -330,8 +330,8 @@ describe RBatch::Log do
 
     it "is warn level" do
       confstr = "log_name: a.log\nlog_level: warn"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new() do | log |
         log.debug("test_debug")
         log.info("test_info")
@@ -351,8 +351,8 @@ describe RBatch::Log do
 
     it "delete old log file which name include <date>" do
       confstr = "log_delete_old_log: true"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       loglist = [*0..20].map do |day|
         File.join(@dir , (Date.today - day).strftime("%Y%m%d") + "_test_delete.log")
       end
@@ -371,8 +371,8 @@ describe RBatch::Log do
   describe "option by both argument and config" do
     it "is prior to argument than config" do
       confstr = "log_name: a.log"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       RBatch::Log.new({:name => "b.log"}) do | log |
         log.info("hoge")
       end
@@ -417,8 +417,8 @@ describe RBatch::Log do
 
     it "option by config" do
       confstr = "log_name: e.log"
-      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
-      RBatch.load_rbatch_config
+      open( RBatch.run_conf_path  , "a" ){|f| f.write(confstr)}
+      RBatch.run_conf.reload
       log = RBatch::Log.new()
       log.info("hoge")
       log.close