rbatch 1.4.0

data/lib/rbatch.rb

@@ -0,0 +1,51 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+
+module RBatch
+  @@program_name = $PROGRAM_NAME
+  module_function
+  def program_name=(f) ; @@program_name = f ; end
+  def program_name ; @@program_name ; end
+  def tmp_dir
+    case RUBY_PLATFORM
+    when /mswin|mingw/
+      return ENV["TEMP"]
+    when /cygwin|linux/
+      return "/tmp/"
+    else
+      raise "Unknown RUBY_PRATFORM : " + RUBY_PLATFORM
+    end
+  end
+  def common_config_path
+    File.join(File.dirname(RBatch.program_name),"..","config","rbatch.yaml")
+  end
+  def common_config
+    if File.exist?(RBatch.common_config_path)
+      yaml = YAML::load_file(RBatch.common_config_path)
+      if yaml
+        return yaml
+      else
+        # If file is emply , YAML::load_file is false
+        return nil
+      end
+    else
+      return nil
+    end
+  end
+end
+
+require 'rbatch/log'
+require 'rbatch/config'
+require 'rbatch/cmd'
+
+# double run check
+if ( RBatch::common_config != nil && RBatch::common_config["forbid_double_run"] )
+  if Dir.exists? RBatch::tmp_dir
+    Dir::foreach(RBatch::tmp_dir) do |f|
+      if (/rbatch_lock/ =~ f)
+        raise "Can not start RBatch. RBatch lock file exists (#{RBatch::tmp_dir}#{f})."
+      end
+    end
+  end
+  # make lockfile
+  Tempfile::new("rbatch_lock",RBatch::tmp_dir)
+end

data/lib/rbatch/cmd.rb

@@ -0,0 +1,118 @@
+require 'fileutils'
+require 'tempfile'
+
+module RBatch
+
+  # External command runcher.
+  # 
+  # * Input cmd_params into Kernel#spawn.
+  # * Write command's stdout and stderr to tmp file.
+  #  * If Platform is "mswin" or "mingw" , then temp directory is ENV["TEMP"]
+  #  * If Platform is "linux" or "cygwin" , then temp directory is "/tmp/"
+  # * Return hash object including stdout, stderr, and exit status.
+  #
+  # ==== Sample 1
+  #  require 'rbatch'
+  #  cmd = RBatch::Cmd("ls")
+  #  r = cmd.run
+  #  p r.stdout
+  #  => "fileA\nfileB\n"
+  #
+  # ==== Sample 2 ( Use option)
+  #  cmd = RBatch::Cmd("ls", {:verbose => true})
+  #  r = cmd.run
+  #
+  # ==== Sample 3 ( Use alias)
+  #  require 'rbatch'
+  #  r = RBatch::cmd("ls")
+  #  p r.stdout
+  #  => "fileA\nfileB\n"
+  #
+  class Cmd
+    @@def_opt = {
+      :raise     => false
+    }
+    @cmd_str
+    @opt
+
+    # Cmd instance
+    #
+    # ==== Params
+    # +cmd_str+ = Command string. Such ad "ls -l"
+    # +opt+ = Option hash object. Hash keys is follows.
+    # - +:raise+ (Boolean) = If command exit status is not 0, raise exception. Default is false.
+    def initialize(cmd_str,opt = nil)
+      raise(CmdException,"Command string is nil") if cmd_str.nil?
+      @cmd_str = cmd_str
+      # 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.common_config != nil \
+          && RBatch.common_config["cmd_" + key.to_s] != nil
+          # use config
+          @opt[key] = RBatch.common_config["cmd_" + key.to_s]
+        else
+          # use default
+        end
+      end
+    end
+
+    # Run command
+    #
+    # ==== Return
+    # instance of RBatch::CmdResult
+    def run()
+      stdout_file = Tempfile::new("rbatch_tmpout",RBatch::tmp_dir)
+      stderr_file = Tempfile::new("rbatch_tmperr",RBatch::tmp_dir)
+      pid = spawn(@cmd_str,:out => [stdout_file,"w"],:err => [stderr_file,"w"])
+      status =  Process.waitpid2(pid)[1] >> 8
+      result = RBatch::CmdResult.new(stdout_file,stderr_file,status,@cmd_str)
+      if @opt[:raise] && status != 0
+        raise(CmdException,"Command exit status is not 0. result: " + result.to_s)
+      end
+      return result
+    end
+  end
+
+  class CmdResult
+    @stdout_file
+    @stderr_file
+    @status
+    @cmd_str
+    def initialize(stdout_file, stderr_file, status, cmd_str)
+      @stdout_file = stdout_file
+      @stderr_file = stderr_file
+      @status = status
+      @cmd_str = cmd_str
+    end
+    def stdout_file ; @stdout_file ; end
+    def stderr_file ; @stderr_file ; end
+    def status      ; @status      ; end
+    def cmd_str     ; @cmd_str     ; end
+    def stdout
+      File.read(@stdout_file)
+    end
+    def stderr
+      File.read(@stderr_file)
+    end
+    def to_h
+      {:cmd_str => @cmd_str,:stdout => stdout, :stderr => stderr, :status => status}
+    end
+    def to_s
+      to_h.to_s
+    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
+
+end

data/lib/rbatch/config.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+require 'pathname'
+
+module RBatch
+
+  module_function
+
+  # Read config file and return hash opject.
+  # 
+  # Default config file path is "../config/(Program name).yaml"
+  # ==== Sample
+  # config : ./config/sample2.yaml
+  #  key: value
+  #  array:
+  #   - item1
+  #   - item2
+  #   - item3
+  # script : ./bin/sample2.rb
+  #  require 'rbatch'
+  #  p RBatch::config
+  #  => {"key" => "value", "array" => ["item1", "item2", "item3"]}
+  def config
+    file = Pathname(File.basename(RBatch.program_name)).sub_ext(".yaml").to_s
+    dir = File.join(File.join(File.dirname(RBatch.program_name),".."),"config")
+    return YAML::load_file(File.join(dir,file))
+  end
+
+end
+

data/lib/rbatch/log.rb

@@ -0,0 +1,205 @@
+require 'logger'
+require 'fileutils'
+require 'pathname'
+
+module RBatch
+  #=== About RBatch::Log
+  #
+  #Use Auto Logging block, RBatch automatically write to logfile.
+  #
+  #Log file default location is "../log/YYYYMMDD_HHMMSS_${PROG_NAME}.log" .
+  #
+  #If exception occuerd, then RBatch write stack trace to logfile.
+  #
+  #=== Sample
+  #
+  #script : ./bin/sample1.rb
+  #
+  # require 'rbatch'
+  # 
+  # RBatch::Log.new(){ |log|  # Logging block
+  #   log.info "info string"
+  #   log.error "error string"
+  #   raise "exception"
+  # }
+  #
+  #
+  #logfile : ./log/20121020_005953_sample1.log
+  #
+  # # Logfile created on 2012-10-20 00:59:53 +0900 by logger.rb/25413
+  # I, [2012-10-20T00:59:53.895528 #3208]  INFO -- : info string
+  # E, [2012-10-20T00:59:53.895582 #3208] ERROR -- : error string
+  # F, [2012-10-20T00:59:53.895629 #3208] FATAL -- : Caught exception; existing 1
+  # F, [2012-10-20T00:59:53.895667 #3208] FATAL -- : exception (RuntimeError)
+  # test.rb:6:in `block in <main>'
+  # /usr/local/lib/ruby192/lib/ruby/gems/1.9.1/gems/rbatch-1.0.0/lib/rbatch/auto_logger.rb:37:in `initialize'
+  # test.rb:3:in `new'
+  # test.rb:3:in `<main>'
+  #
+  class Log
+    @@verbose = false
+    @@def_opt = {
+      :name      => "<date>_<time>_<prog>.log",
+      :dir       => File.join(File.dirname(RBatch.program_name), ".." , "log"),
+      :formatter => nil,
+      :append    => true,
+      :level     => "info",
+      :stdout    => false,
+      :quiet     => false,
+      :delete_old_log => false,
+      :delete_old_log_date => 7
+    }
+    @@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
+
+    # Auto Logging Block.
+    # 
+    # ==== Params
+    # +opt+ = Option hash object. Hash keys is follows.
+    # - +:name+ (String) = log file name. Default is "<date>_<time>_<prog>.log"
+    # - +:dir+ (String) = log direcotry path. Default is "../log"
+    # - +:level+ (String) = log level. ["debug"|"info"|"warn"|"error"|"fatal"] . Default is "info".
+    # - +:append+ (Boolean) = appned to log or not(=overwrite). Default is ture.
+    # - +:formatter+ (Logger#formatter) = log formatter. instance of Logger#formatter
+    # - +:stdout+ (Boolean) = print string both logfile and STDOUT. Default is false.
+    # - +:quiet+ (Boolean) = run quiet mode. print STDOUT nothing.  Default is true.
+    # ==== 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
+      @opt = @@def_opt.clone
+      @@def_opt.each_key do |key|
+        if opt != nil  && opt[key] != nil
+          # use argument
+          @opt[key] = opt[key]
+        elsif RBatch.common_config != nil \
+          && RBatch.common_config["log_" + key.to_s] != nil
+          # use config
+          @opt[key] = RBatch.common_config["log_" + key.to_s]
+        else
+          # use default
+        end
+      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.gsub!("<date>", Time.now.strftime("%Y%m%d"))
+      @file_name.gsub!("<time>", Time.now.strftime("%H%M%S"))
+      @file_name.gsub!("<prog>", @prog_base)
+      path = File.join(@opt[:dir],@file_name)
+      # create Logger instance
+      begin
+        if @opt[: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]
+        raise e
+      end
+      # set logger option
+      @log.formatter = @opt[:formatter] if @opt[:formatter]
+      @log.level = @@log_level_map[@opt[:level]]
+      if @opt[: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]]
+      end
+      puts "Log file: " + path if ! @opt[:quiet]
+      # delete old log
+      self.delete_old_log(@opt[:delete_old_log_date]) if @opt[:delete_old_log]
+      if block_given?
+        begin
+          yield self
+        rescue => e
+          self.fatal("Caught exception; existing 1")
+          self.fatal(e)
+          exit 1
+        ensure
+          self.close
+        end
+      end
+    end
+
+    def fatal(a)
+      @stdout_log.fatal(a) if @opt[:stdout]
+      @log.fatal(a)
+    end
+
+    def error(a)
+      @stdout_log.error(a) if @opt[:stdout]
+      @log.error(a)
+    end
+
+    def warn(a)
+      @stdout_log.warn(a) if @opt[:stdout]
+      @log.warn(a)
+    end
+
+    def info(a)
+      @stdout_log.info(a) if @opt[:stdout]
+      @log.info(a)
+    end
+
+    def debug(a)
+      @stdout_log.debug(a) if @opt[:stdout]
+      @log.debug(a)
+    end
+
+    def close
+      @stdout_log.close if @opt[:stdout]
+      @log.close
+    end
+
+    # Delete old log files.
+    # If @opt[: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|
+          r = Regexp.new("^" \
+                         + @opt[: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))
+          end
+        end
+      end
+    end
+  end # end class
+end # end module
+

data/sample/bin/file_batch_copy.rb

@@ -0,0 +1,9 @@
+require 'rbatch'
+require 'fileutils'
+RBatch::Log.new do |log|
+  RBatch::config["file_list"].each do | file |
+    log.info("cp -r " + file + " " + RBatch::config["backup_dir"])
+    FileUtils.cp_r(file,RBatch::config["backup_dir"])
+  end
+end
+

data/sample/bin/openldap_backup.rb

@@ -0,0 +1,7 @@
+require 'rbatch'
+
+RBatch::Log.new do |log|
+  log.info("start openldap backup")
+  cmd_str = "slapcat -l " + RBatch::config["backup_dir"]
+  RBatch::cmd(cmd_str)
+end

data/sample/bin/test.rb

@@ -0,0 +1,12 @@
+require 'rbatch'
+#RBatch::Log.verbose=true
+RBatch::Log.new({ :quiet => true } ) do |log|
+  log.delete_old_log
+p "--"
+  log.delete_old_log 1
+p "--"
+  log.delete_old_log 2
+p "--"
+  log.delete_old_log 3
+
+end

data/sample/config/file_batch_copy.yaml

@@ -0,0 +1,5 @@
+file_list:
+  - /etc/hosts
+  - /etc/ntp.conf
+  - notexist-file
+backup_dir: /tmp

data/sample/config/openldap_backup.yaml

@@ -0,0 +1,2 @@
+backup_dir: /tmp
+