rbatch 2.1.1 → 2.1.2

data/lib/rbatch/variables.rb

@@ -0,0 +1,82 @@
+require 'rbatch/run_conf'
+
+module RBatch
+  class Variables
+    attr :vars,:run_conf,:merged_opt
+    def initialize(run_conf=nil)
+      @merged_opt = {}
+      @vars = {
+        :program_name => $PROGRAM_NAME ,
+        :program_path => File.expand_path($PROGRAM_NAME) ,
+        :program_base => File.basename($PROGRAM_NAME),
+        :date => Time.now.strftime("%Y%m%d"),
+        :time => Time.now.strftime("%H%M%S"),
+      }
+
+      if ENV["RB_VERBOSE"]
+        @vars[:journal_verbose] = ENV["RB_VERBOSE"].to_i
+      else
+        @vars[:journal_verbose] = 1
+      end
+
+      case RUBY_PLATFORM
+      when /mswin|mingw/
+        @vars[:host_name] =  ENV["COMPUTERNAME"] ? ENV["COMPUTERNAME"] : "unknownhost"
+      when /cygwin|linux/
+        @vars[:host_name] = ENV["HOSTNAME"] ? ENV["HOSTNAME"] : "unknownhost"
+      else
+        @vars[:host_name] = "unknownhost"
+      end
+
+      if  ENV["RB_HOME"]
+        @vars[:home_dir] = File.expand_path(ENV["RB_HOME"])
+      else
+        @vars[:home_dir] = File.expand_path(File.join(File.dirname(@vars[:program_name]), ".."))
+      end
+      @vars[:run_conf_path] = File.join(@vars[:home_dir],".rbatchrc")
+      @run_conf = RunConf.new(@vars[:run_conf_path]) # load run_conf
+      @vars.merge!(@run_conf.opt)
+      @vars[:common_config_path] = File.join(@vars[:conf_dir],@vars[:common_conf_name])
+      @vars[:config_path] = File.join(@vars[:conf_dir],Pathname(File.basename(@vars[:program_name])).sub_ext(".yaml").to_s)
+    end #end def
+
+    def[](key)
+      if @vars.has_key?(key)
+        if @vars[key].class == String
+          @vars[key]
+            .gsub("<home>", @vars[:home_dir])
+            .gsub("<date>", @vars[:date])
+            .gsub("<time>", @vars[:time])
+            .gsub("<prog>", @vars[:program_base])
+            .gsub("<host>", @vars[:host_name])
+        else
+          @vars[key]
+        end
+      else
+        raise RBatch::VariablesException, "no such key exist :" + key.to_s
+      end
+    end
+
+    def raw_value(key)
+      if @vars.has_key?(key)
+        @vars[key]
+      else
+        raise RBatch::VariablesException, "no such key exist :" + key.to_s
+      end
+    end
+
+    def merge!(merged_opt)
+      @merged_opt = merged_opt
+      @vars.merge!(merged_opt)
+      return nil
+    end
+
+    def merge(merged_opt)
+      @merged_opt = merged_opt
+      @vars.merge!(merged_opt)
+      return self
+    end
+
+  end
+  class RBatch::VariablesException < StandardError ; end
+end

data/lib/rbatch/version.rb

@@ -1,3 +1,3 @@
 module RBatch
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 end

data/lib/rbatch.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
-require 'yaml'
+
+require 'rbatch/controller'
 
 module RBatch
   @@ctrl = nil
@@ -7,43 +8,13 @@ module RBatch
   def init
     @@ctrl = RBatch::Controller.new
   end
-  def ctrl
-    @@ctrl
-  end
-  def run_conf
-    @@ctrl.run_conf
-  end
-  def run_conf_path ; @@ctrl.run_conf_path ; end
-
-  # Config Reader
-  #
-  # Read config file and return hash opject. If the key does not exist in config file, raise RBatch::Config::Exception.
-  # 
-  # Default config file path is "${RB_HOME}/conf/(program base name).yaml"
-  # ==== Sample
-  # config : ${RB_HOME}/conf/sample2.yaml
-  #  key: value
-  #  array:
-  #   - item1
-  #   - item2
-  #   - item3
-  # script : ${RB_HOME}/bin/sample2.rb
-  #  require 'rbatch'
-  #  p RBatch::Config.new
-  #  # or  p RBatch::config
-  #  => {"key" => "value", "array" => ["item1", "item2", "item3"]}
-  def config ; @@ctrl.config ; end
-  def common_config ; @@ctrl.common_config ; end
-  def journal(a,b) ; @@ctrl.journal(a,b) ; end
+  def ctrl ; @@ctrl ; end
+  def vars ; @@ctrl.vars ; end
+  def config               ; @@ctrl.config ; end
+  def common_config        ; @@ctrl.common_config ; end
+  def cmd(cmd_str,opt=nil) ; @@ctrl.cmd(cmd_str,opt) ; end
 end
 
 # main
-require 'rbatch/controller'
-require 'rbatch/run_conf'
-require 'rbatch/double_run_checker'
-require 'rbatch/log'
-require 'rbatch/config'
-require 'rbatch/cmd'
-
 RBatch::init
 

data/sample/.rbatchrc

@@ -10,10 +10,9 @@
 # Conf Directory
 #
 #   Default is "<home>/conf"
-#
 #   <home> is replaced to ${RB_HOME}
 #
-#conf_dir: <home>/config
+#conf_dir: <home>/config/
 #conf_dir: /etc/rbatch/
 
 # Common config file name
@@ -22,6 +21,21 @@
 #
 #common_conf_name: share.yaml
 
+# Library Directory
+#
+#   Default is "<home>/lib"
+#   <home> is replaced to ${RB_HOME}
+#
+#lib_dir: /usr/local/lib/rbatch/
+
+# Auto Library Load
+#
+#   Default is true
+#   If true, require "(library directory)/*.rb" before script run.
+#
+#auto_lib_load: true
+#auto_lib_load: false
+
 # Forbit Script Double Run
 #
 #   Default is false.
@@ -71,7 +85,7 @@
 #log_name : "<date>_<time>_<prog>.log"
 #log_name : "<date>_<prog>.log"
 
-# Append log or not
+# Append Log
 #
 #   Default is ture.
 #
@@ -100,8 +114,8 @@
 #
 #   Default is false.
 #   If this is true, delete old log file when RBatch::Log.new is called.
-#   A log file to delete is a log file which was made by the RBatch::Log instance, 
-#   and log filename format include "<date>".
+#   A log file to delete is a log file which was made by the
+#   RBatch::Log instance, and log filename format include "<date>".
 #
 #log_delete_old_log: true
 #log_delete_old_log: false
@@ -113,9 +127,10 @@
 #log_delete_old_log_date: 14
 
 # Send mail or not
-# 
+#
 #   Default is false.
-#   When log.error(msg) or log.fatal(msg) called , send e-mail including "msg". 
+#   When log.error(msg) or log.fatal(msg) called , send e-mail
+#   including "msg".
 #
 #log_send_mail : true
 
@@ -125,3 +140,22 @@
 #log_mail_from : "xxx@sample.com"
 #log_mail_server_host : "localhost"
 #log_mail_server_port : 25
+
+# RBatch Journal Message Level
+#
+#   Default is 1
+#   If 2, put more journal messages to STDOUT.
+#   If 0, put nothing.
+#   Example of journal essages are follows.
+#       [RBatch] Load Config  : "../conf/hoge.yaml"
+#
+#rbatch_journal_level = 2
+#rbatch_journal_level = 0
+
+# Mix RBatch Journal to Logs
+#
+#   Default is true.
+#   If true, mix RBatch journal messages to log file(s) which is(are) opened at time.
+#
+#mix_rbatch_journal_to_logs : true
+#mix_rbatch_journal_to_logs : false

data/spec/01_rbach_spec.rb

@@ -0,0 +1,99 @@
+require 'tmpdir'
+
+describe "RBatch" do
+  before :all do
+    @rand = "rbatch_test_" + rand.to_s
+    @home = File.join(Dir.tmpdir, @rand)
+    @log_dir = File.join(@home,"log")
+    @conf_dir = File.join(@home,"conf")
+    ENV["RB_HOME"]=@home
+
+    Dir.mkdir(@home)
+    Dir.mkdir(@log_dir)
+    Dir.mkdir(@conf_dir)
+    open( File.join(@home,".rbatchrc") , "a" ){|f|
+      f.write("log_name : hoge.log")
+    }
+
+    open( File.join(@conf_dir,"rspec.yaml") , "a" ){|f|
+      f.write("key1 : value1")
+    }
+
+    open( File.join(@conf_dir,"common.yaml") , "a" ){|f|
+      f.write("key2 : value2")
+    }
+
+    # stop STODOUT output
+    #$stdout = File.open(File.join(@home,"out.txt"),"w")
+    #$stderr = File.open(File.join(@home,"err.txt"),"w")
+  end
+
+  after :all do
+  #  FileUtils.rm_rf(@home)
+  end
+
+  it "success" do
+    require 'rbatch'
+
+    result = RBatch.cmd("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'")
+    expect(result.stdout.chomp).to eq "1"
+    expect(result.stderr.chomp).to eq "2"
+    expect(result.status).to eq 0
+    expect{
+      RBatch.cmd("ruby -e 'exit 1;'",{:raise => true})
+    }.to raise_error(RBatch::CmdException)
+
+
+    expect(RBatch.config["key1"]).to eq "value1"
+    expect{ RBatch.config["noexist"] }.to raise_error RBatch::ConfigException
+
+    expect(RBatch.common_config["key2"]).to eq "value2"
+    expect{ RBatch.common_config["noexist"] }.to raise_error RBatch::ConfigException
+
+    expect{
+      RBatch::Log.new do |log|
+        log.info("test_string")
+        RBatch.ctrl.journal.put 2,"var2"
+        RBatch.ctrl.journal.put 1,"var1"
+        RBatch.ctrl.journal.put 0,"var0"
+        RBatch.config["noexist2"]
+      end
+    }.to raise_error SystemExit
+
+    Dir::foreach(RBatch.vars[:log_dir]) do |f|
+      if ! (/\.+$/ =~ f)
+        File::open(File.join(RBatch.vars[:log_dir] , f)) {|f|
+          expect(f.read).to match /test_string/
+        }
+      end
+    end
+
+    # check journal
+    expect(RBatch.ctrl.journal.journals[0]).to match /START RBatch/
+    expect(RBatch.ctrl.journal.journals[1]).to match Regexp.new(@rand)
+    expect(RBatch.ctrl.journal.journals[2]).to match /batchrc/
+    expect(RBatch.ctrl.journal.journals[3]).to match /common.yaml/
+    expect(RBatch.ctrl.journal.journals[4]).to match /rspec.yaml/
+    expect(RBatch.ctrl.journal.journals[5]).to match /Start Script/
+    expect(RBatch.ctrl.journal.journals[6]).to match /Logging Start/
+    expect(RBatch.ctrl.journal.journals[7]).to match /var1/
+    expect(RBatch.ctrl.journal.journals[8]).to match /var0/
+
+    # check log
+    f = open(File.join(@home,"log","hoge.log")).read
+    lines = f.split("\n")
+
+    expect(lines[0]).to match /START RBatch/
+    expect(lines[1]).to match Regexp.new(@rand)
+    expect(lines[2]).to match /batchrc/
+    expect(lines[3]).to match /common.yaml/
+    expect(lines[4]).to match /rspec.yaml/
+    expect(lines[5]).to match /Start Script/
+    expect(lines[6]).to match /Logging Start/
+    expect(lines[7]).to match /test_string/
+    expect(lines[8]).to match /var1/
+    expect(lines[9]).to match /var0/
+    expect(lines[10]).to match /FATAL/
+
+  end
+end

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

@@ -1,43 +1,46 @@
-require File.expand_path(File.join( File.dirname(__FILE__), 'spec_helper'))
+require 'simplecov'
+SimpleCov.start
 
-require 'rbatch'
+require 'rbatch/variables'
+require 'rbatch/cmd'
 
 describe RBatch::Cmd do
   before :each do
-    RBatch.run_conf.reset
+    @def_vars = RBatch::Variables.new()
+    RBatch::Cmd.def_vars = @def_vars
   end
 
   it "run command which status is 0" do
-    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'"
+    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'").run
     expect(result.stdout.chomp).to eq "1"
     expect(result.stderr.chomp).to eq "2"
     expect(result.status).to eq 0
   end
   it "run command which status is 1" do
-    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'").run
     expect(result.stdout.chomp).to eq "1"
     expect(result.stderr.chomp).to eq "2"
     expect(result.status).to eq 1
   end
   it "raise error when command does not exist" do
     expect {
-      RBatch::cmd "not_exist_command"
+      RBatch::Cmd.new("not_exist_command").run
     }.to raise_error(Errno::ENOENT)
   end
   it "run command which stdout size is greater than 65534byte" do
-    result = RBatch::cmd "ruby -e '100000.times{print 0}'"
+    result = RBatch::Cmd.new("ruby -e '100000.times{print 0}'").run
     expect(result.stdout.chomp.size).to eq 100000
     expect(result.stderr.chomp).to eq ""
     expect(result.status).to eq 0
   end
   it "run command which stdout size is greater than 65534bytes with status 1" do
-    result = RBatch::cmd "ruby -e '100000.times{print 0}; exit 1'"
+    result = RBatch::Cmd.new("ruby -e '100000.times{print 0}; exit 1'").run
     expect(result.stdout.chomp.size).to eq 100000
     expect(result.stderr.chomp).to eq ""
     expect(result.status).to eq 1
   end
   it "run command which status is grater than 256" do
-    result = RBatch::cmd  "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 300;'"
+    result = RBatch::Cmd.new( "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 300;'").run
     expect(result.stdout.chomp).to eq "1"
     expect(result.stderr.chomp).to eq "2"
     case RUBY_PLATFORM
@@ -49,13 +52,13 @@ describe RBatch::Cmd do
     end
   end
   it "run to_h method" do
-    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'").run
     expect(result.to_h[:stdout]).to eq "1"
     expect(result.to_h[:stderr]).to eq "2"
     expect(result.to_h[:status]).to eq 1
   end
   it "run to_s method" do
-    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'").run
     expect(result.to_s).to eq "{:cmd_str=>\"ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'\", :stdout=>\"1\", :stderr=>\"2\", :status=>1}"
   end
   it "raise error when command is nil" do
@@ -63,61 +66,55 @@ describe RBatch::Cmd do
       RBatch::Cmd.new(nil)
     }.to raise_error(RBatch::CmdException)
   end
-  it "run RBatch::Cmd.new method" do
-    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'").run
-    expect(result.stdout.chomp).to eq "1"
-    expect(result.stderr.chomp).to eq "2"
-    expect(result.status).to eq 0
-  end
-
 
   describe "option by argument" do
-    describe "timeout" do
-      it "run successfuly when command is short time" do
-        opt = {:timeout => 2}
-        expect {
-          RBatch::cmd("ruby -e 'sleep 1'",opt)
-        }.to_not raise_error
-      end
-      it "raise timeout error when command is long time" do
-        opt = {:timeout => 1}
+    describe "raise" do
+      it "raise error when command status is not 0" do
+        opt = {:raise => true}
         expect {
-          RBatch::cmd("ruby -e 'sleep 2'",opt)
+          RBatch::Cmd.new("ruby -e 'exit 1;'",opt).run
         }.to raise_error(RBatch::CmdException)
       end
     end
-  end
-
-  describe "option by argument" do
     describe "timeout" do
       it "run successfuly when command is short time" do
         opt = {:timeout => 2}
         expect {
-          RBatch::cmd("ruby -e 'sleep 1'",opt)
+          RBatch::Cmd.new("ruby -e 'sleep 1'",opt).run
         }.to_not raise_error
       end
       it "raise timeout error when command is long time" do
         opt = {:timeout => 1}
         expect {
-          RBatch::cmd("ruby -e 'sleep 2'",opt)
+          RBatch::Cmd.new("ruby -e 'sleep 2'",opt).run
         }.to raise_error(RBatch::CmdException)
       end
     end
   end
 
-  describe "option by config" do
-    before :all do
-      @config_dir=File.join(ENV["RB_HOME"],"conf")
-      @config_file = File.join(@config_dir , "rbatch.yaml")
-      Dir::mkdir @config_dir if ! Dir.exists? @config_dir
-    end
+  describe "option by run_conf" do
     describe "raise" do
-      before :each do
-        RBatch.run_conf[:cmd_raise] = true
-      end
       it "raise error when command status is not 0" do
+        @def_vars.merge!({:cmd_raise => true})
+        RBatch::Cmd.def_vars = @def_vars
+        expect {
+          RBatch::Cmd.new("ruby -e 'exit 1;'").run
+        }.to raise_error(RBatch::CmdException)
+      end
+    end
+    describe "timeout" do
+      it "run successfuly when command is short time" do
+        @def_vars.merge!({:cmd_timeout => 2})
+        RBatch::Cmd.def_vars = @def_vars
+        expect {
+          RBatch::Cmd.new("ruby -e 'sleep 1'").run
+        }.to_not raise_error
+      end
+      it "raise timeout error when command is long time" do
+        @def_vars.merge!({:cmd_timeout => 1})
+        RBatch::Cmd.def_vars = @def_vars
         expect {
-          RBatch::cmd "ruby -e 'exit 1;'"
+          RBatch::Cmd.new("ruby -e 'sleep 2'").run
         }.to raise_error(RBatch::CmdException)
       end
     end

data/spec/rbatch/config_spec.rb

@@ -0,0 +1,67 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'tmpdir'
+require 'rbatch/config'
+
+describe RBatch::Config do
+  before :all do
+  end
+
+  before :each do
+    @path = File.join(Dir.tmpdir , rand.to_s)
+  end
+  
+  after :each do
+    FileUtils.rm @path if File.exists? @path
+  end
+  
+  it "read" do
+    open( @path  , "w" ){|f| f.write("key: value")}
+    expect(RBatch::Config.new(@path)["key"]).to eq "value"
+  end
+  
+  it "key is Symbol" do
+    open( @path  , "w" ){|f| f.write(":key: value")}
+    expect(RBatch::Config.new(@path)[:key]).to eq "value"
+  end
+  
+  it "raise error when config does not exist" do
+    expect {
+      RBatch::Config.new(@path)["hoge"]
+    }.to raise_error(RBatch::ConfigException)
+    expect {
+      RBatch::Config.new(@path).to_h
+    }.to raise_error(RBatch::ConfigException)
+    expect {
+      RBatch::Config.new(@path).to_s
+    }.to raise_error(RBatch::ConfigException)
+  end
+  
+  it "read config twice" do
+    open( @path  , "w" ){|f| f.write("key: value")}
+    expect(RBatch::Config.new(@path)["key"]).to eq "value"
+    expect(RBatch::Config.new(@path)["key"]).to eq "value"
+  end
+  
+  it "raise error when read value which key does not exist" do
+    open( @path  , "w" ){|f| f.write("key: value")}
+    expect {
+      RBatch::Config.new(@path)["not_exist"]
+    }.to raise_error(RBatch::ConfigException)
+  end
+  
+  it "raise error when read value which key mistake String for Symbol" do
+    open( @path  , "w" ){|f| f.write("key: value")}
+    expect {
+      RBatch::Config.new(@path)[:key]
+    }.to raise_error(RBatch::ConfigException)
+  end
+  
+  it "raise error when read value which key mistake Symbol for String" do
+    open( @path  , "w" ){|f| f.write(":key: value")}
+    expect {
+      RBatch::Config.new(@path)["key"]
+    }.to raise_error(RBatch::ConfigException)
+  end
+end

data/spec/rbatch/controller_spec.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'tmpdir'
+require 'rbatch/controller'
+describe RBatch::Controller do
+
+  before :all do
+    @home = File.join(Dir.tmpdir, "rbatch_test_" + rand.to_s)
+  end
+
+  after :each do
+  end
+
+  it "success" do
+    RBatch::Variables.new()
+  end
+end

data/spec/{double_run_checker_spec.rb → rbatch/double_run_checker_spec.rb}

@@ -1,3 +1,6 @@
+require 'simplecov'
+SimpleCov.start
+
 require 'rbatch/double_run_checker'
 
 describe RBatch::DoubleRunChecker do

data/spec/rbatch/journal_spec.rb

@@ -0,0 +1,29 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rbatch/journal'
+
+describe RBatch::Journal do
+  it "default" do
+    @j = RBatch::Journal.new
+    expect(@j.journal_verbose) == 1
+  end
+
+  it "is passed argument" do
+    @j = RBatch::Journal.new(2)
+    expect(@j.journal_verbose) == 2
+  end
+
+  it "ENV is set" do
+     ENV["RB_VERBOSE"] = "0"
+    @j = RBatch::Journal.new
+    expect(@j.journal_verbose) == 0
+  end
+
+  it "both argument and ENV are set" do
+     ENV["RB_VERBOSE"] = "0"
+    @j = RBatch::Journal.new(2)
+    expect(@j.journal_verbose) == 2
+  end
+end
+