simple_rotate 1.0.0 → 1.1.0

data/lib/simple_rotate/internal/process_sync_mixin.rb

@@ -0,0 +1,48 @@
+module ProcessSyncMixin
+    @@scheduled_del_lockfile = false
+    @@tempf_name             = nil
+    @@tempf                  = nil
+
+    def locked?
+        return false if !tempf_exists?
+
+        # return false, if locked by another
+        status = @@tempf.flock(File::LOCK_EX | File::LOCK_NB)
+
+        return status == false
+    end
+
+    # lock the temp file
+    def lock
+        create_tempfile if !tempf_exists?
+
+        reopen_temp_file
+
+        cnt = 0
+        begin
+            @@tempf.flock(File::LOCK_EX)
+
+        rescue
+            cnt += 1
+            if (cnt <= @try_limit)
+                sleep(0.5)
+                create_tempfile if !tempf_exists?
+                retry
+            else
+              SimpleRotate::Error.warning("It was not possible to lock (tried 3times) => #{@@tempf_name}")
+              return false
+            end
+        end
+    end
+
+    # unlock the temp file
+    def unlock
+      return nil if !tempf_exists?
+
+      begin
+          @@tempf.flock(File::LOCK_UN)
+      rescue
+          SimpleRotate::Error.warning("It was not possible to unlock => #{@@tempf_name}")
+      end
+    end
+end

data/lib/simple_rotate/internal/rotate_term.rb

@@ -0,0 +1,7 @@
+class SimpleRotate
+    module RotateTerm
+        TERM_DAILY     = 1
+        TERM_WEEKLY    = 7
+        TERM_MONTHLY   = 30
+    end
+end

data/lib/simple_rotate/internal/validator.rb

@@ -0,0 +1,45 @@
+class SimpleRotate
+  module Validator
+    def valid_file_name
+      # stdout only
+      if @file_name.is_a?(Symbol) && @file_name == :STDOUT
+        @only_stdout = true
+        return true
+      end
+
+      # not string
+      if !@file_name.is_a?(String)
+        SimpleRotate::Error.argv("file_name", @file_name)
+      end
+
+      # directory?
+      if File.directory?(@file_name)
+        msg = "ERROR => #{@file_name} is a Directory!"
+        SimpleRotate::Error.warning(msg)
+        SimpleRotate::Error.argv("file_name", @file_name)
+      end
+
+      return true
+    end
+
+    def valid_int(param, argv)
+      if !argv.is_a?(Integer)
+        SimpleRotate::Error.argv(param, argv)
+
+      elsif argv < 0
+        msg = %{You can't specify the negative value!}
+        SimpleRotate::Error.warning(msg)
+        SimpleRotate::Error.argv(param, argv)
+      end
+    end
+
+    def valid_bool(param, argv)
+      argv = true  if argv == 1
+      argv = false if argv == 0
+      if !(argv.instance_of?(TrueClass) || argv.instance_of?(FalseClass))
+        SimpleRotate::Error.argv(param, argv)
+      end
+      return true
+    end
+  end
+end

data/lib/simple_rotate/private.rb

@@ -0,0 +1,436 @@
+#----------------
+# private methods
+#----------------
+class SimpleRotate
+    # log file is not IO class or stdout only
+    # @return bool
+    private
+    def logf_not_usable
+        !@logf.is_a?(IO) || @only_stdout
+    end
+
+    # load zlib lib
+    private
+    def use_zlib
+        begin
+            require "zlib"
+            @compress_level = Zlib::DEFAULT_COMPRESSION if @compress_level == nil
+
+        rescue LoadError
+            SimpleRotate::Error.load("zlib")
+        end
+    end
+
+    # open or generate the log file
+    private
+    def prepare_logf
+        if File.exist?(@file_name)
+            # open the exists file, add mode
+            openadd
+
+            # rotate it if necessary
+            rotate_if
+
+        else
+            gen_new_logf
+        end
+    end
+
+    # generate new log file
+    private
+    def gen_new_logf
+        begin
+            @logf = File.open(@file_name, File::RDWR|File::CREAT|File::TRUNC)
+            gtime = Time.new.to_i
+            @logf.puts("created@#{gtime}@Please don't delete this line")
+            @logf.close
+
+          rescue
+              SimpleRotate::Error.open(@file_name)
+          end
+
+          openadd
+    end
+
+    # if file or directory exist, call error
+    private
+    def exist_error(file)
+        SimpleRotate::Error.exist(file, "File")      if File.exist?(file)
+        SimpleRotate::Error.exist(file, "Directory") if Dir.exist?(file)
+
+        return true
+    end
+
+  # define default instance vars
+    private
+    def include_defaults
+        que = []
+        que << [%{@threshold},        %{LOG_LEVEL_2}]
+        que << [%{@log_level},        %{2}]
+        que << [%{@logging_format},   %{"[$DATE] - $LEVEL : $LOG"}]
+        que << [%{@date_format},      %{"%Y/%m/%d %H:%M:%S"}]
+        que << [%{@term_format},      %{"%Y%m%d"}]
+        que << [%{@rename_format},    %{"."}]
+        que << [%{@with_stdout},      %{false}]
+        que << [%{@only_stdout},      %{false}]
+        que << [%{@no_wcheck},        %{false}]
+        que << [%{@sync_inode_limit}, %{3}]
+        que << [%{@no_sync_inode},    %{false}]
+        que << [%{@enable_wflush},    %{false}]
+        que << [%{@compress},         %{false}]
+        que << [%{@is_psync},         %{false}]
+        que << [%{@sleep_time},       %{0}]
+
+        que.each do |q|
+            if eval(%{#{q[0]} == nil})
+                eval(%{#{q[0]} = #{q[1]}})
+            end
+        end
+    end
+
+    # Whether to rotate by file age?
+    # @return bool 
+    private
+    def rotate_by_term?
+        if @limit.is_a?(Integer)
+            return false
+
+        elsif @limit.is_a?(String)
+            return @limit.to_i == 0
+
+        else
+            SimpleRotate::Error.argv("limit", @limit)
+        end
+    end
+
+    # Open the log file, add mode
+    private
+    def openadd
+        @logf = File.open(@file_name, File::RDWR|File::CREAT|File::APPEND)
+
+        # refresh object
+        @psync = ProcessSync.new(self)
+    end
+
+    # get cretated time of the log file
+    # @return Time
+    private
+    def get_logf_generate_time
+        pos = @logf.pos
+        begin
+            @logf.rewind
+            stamp = @logf.readline.split("@")
+            @logf.seek(pos)
+            gtime = Time.at(stamp[1].to_i)
+
+        rescue StandardError, SyntaxError
+            msg   = "Can't get file creation time!"
+            gtime = Time.now
+            SimpleRotate::Error.warning(msg)
+        end
+
+        return gtime
+    end
+
+    # @return int
+    private
+    def set_days_cnt_of_term
+      begin
+          @dayc = eval("TERM_#{@limit}")
+
+      rescue NameError
+          SimpleRotate::Error.argv("limit", @limit)
+      end
+    end
+
+    # log file size over 'limit_size'? 
+    # @return bool|nil
+    private
+    def over_size?
+        return nil if logf_not_usable
+
+        begin
+            rst =  File.size(@file_name) > @limit_size
+        rescue
+            rst = false
+        end
+
+        return rst
+    end
+
+    private
+    def safe_over_size?
+        rst = nil
+        synchronize do
+            @psync.lock
+            rst = over_size?
+            @psync.unlock
+        end
+
+        return rst
+    end
+
+    # logfile's elapsed days is over limit?
+    # @return bool
+    private
+    def over_term?
+        return nil if logf_not_usable
+
+        begin
+            now_time       = Time.now
+            gen_time       = get_logf_generate_time
+            estimated_time = gen_time + (60 * 60 * 24 * @dayc)
+            rst            = estimated_time <=  now_time
+
+        rescue
+            rst = false
+        end
+
+        return rst
+    end
+
+    private
+    def safe_over_term?
+        rst = nil
+        synchronize do
+            @psync.lock
+            rst = over_term?
+            @psync.unlock
+        end
+
+        return rst
+    end
+
+    # Format the text for logging
+    # the following characters are recognized 
+    # $DATE  => date
+    # $LEVEL => log's severity
+    # $LOG   => your log message
+    # $PID   => process ID
+    # $FILE  => execute file name
+    #
+    # @param  string $log
+    # @return string
+    private
+    def get_trimmed_log(log)
+        log   = log.to_s
+        date  = Time.now.strftime(@date_format)
+        level = eval("LOG_LEVEL_#{@log_level}")
+        return @logging_format.gsub("$DATE", date)
+                              .gsub("$LEVEL", level)
+                              .gsub("$LOG", log)
+                              .gsub("$PID", $$.to_s)
+                              .gsub("$FILE-FUL", File.absolute_path($0))
+                              .gsub("$FILE", File.basename($0))
+    end
+
+    # Whether that is the output of the log level that exceeds the threshold 
+    # @return boolean
+    private
+    def over_threshold?
+        begin
+            return (@log_level >= eval("LEVEL_ID_#{@threshold}"))
+
+        rescue NameError
+            SimpleRotate::Error.argv("threshold", @threshold)
+        end
+    end
+
+    # need rotate?
+    # @return bool
+    private
+    def reached_limit?(mode=:NO_LOCK)
+        # file age rotation
+        if @rotate_by_term
+            is_over_term  = nil
+            if mode == :NO_LOCK
+                is_over_term = over_term?
+            elsif mode == :LOCK
+                is_over_term = safe_over_term?
+            end
+
+            return is_over_term
+        end
+
+        # file size rotation
+        is_over_size = nil
+        if mode == :NO_LOCK
+            is_over_size = over_size?
+        elsif mode == :LOCK
+            is_over_size = safe_over_size?
+        end
+
+        return is_over_size
+    end
+
+    # Rotates as necessary
+    # @return bool
+    private
+    def rotate_if
+        if reached_limit?(:LOCK)
+            rotation
+            return true
+
+        else
+            # no need to rotate
+            return false
+        end
+    end
+
+    # prepare & call #do_rotation
+    private
+    def rotation(mode=:NO_SPEC)
+        synchronize do
+            # if rotationing now by another process, return
+            if @psync.locked? #=> when didn't call #psync, will be return nil
+                return false
+            end
+
+            # lock another process if enable
+            @psync.lock
+
+            do_rotate(mode)
+
+            # unlock another process if enable
+            @psync.unlock
+        end
+    end
+
+    # rotate the log file and open a new one
+    private
+    def do_rotate(mode)
+        return nil if logf_not_usable
+
+        # check already executed rotation?
+        if mode != :FLUSH && !reached_limit?
+            return false 
+        end
+
+        # file age rotation
+        if @rotate_by_term
+            rtn = do_term_rotate
+            return rtn
+        end
+
+        # file size rotation
+        cnt         = 1
+        rotate_name = "#{@file_name}#{@rename_format}#{cnt}"
+        rotate_name += ".gz" if @compress
+
+        if File.exist?(rotate_name)
+            while File.exist?(rotate_name)
+                cnt        += 1
+                rotate_name = "#{@file_name}#{@rename_format}#{cnt}"
+                rotate_name += ".gz" if @compress
+            end
+
+            rename_wait_que = Array.new
+            for nc in 1...cnt
+                break if @rotation == 1
+                if (@compress)
+                    rename_wait_que << "File.rename('#{@file_name}#{@rename_format}#{nc}.gz', '#{@file_name}#{@rename_format}#{nc+1}.gz')"
+                else
+                    rename_wait_que << "File.rename('#{@file_name}#{@rename_format}#{nc}', '#{@file_name}#{@rename_format}#{nc+1}')"
+                end
+
+                if @rotation
+                    next  if @rotation == 0
+                    break if @rotation <= nc+1
+                end
+            end
+
+            rename_wait_que.reverse!
+
+            begin
+                rename_wait_que.each do |do_rename|
+                    eval(do_rename)
+                end
+
+            rescue
+                SimpleRotate::Error.warning(SimpleRotate::Error::ROTATION_FAILED)
+                return false
+            end
+        end
+
+        most_recent_name = "#{@file_name}#{@rename_format}1"
+        post_execute_rotate(most_recent_name)
+    end
+
+    # Rotate the log file now, and open a new one
+    # for rotate by term
+    private
+    def do_term_rotate
+        date        = Time.now.strftime(@term_format)
+        rotate_name = "#{@file_name}#{@rename_format}#{date}"
+
+        # Don't rotation If a file with the same name already exists
+        return false if File.exists?(rotate_name)
+        return false if File.exists?("#{rotate_name}.gz")
+
+        post_execute_rotate(rotate_name)
+    end
+
+    # rename log_file & generate new one
+    private
+    def post_execute_rotate(after_name)
+        begin
+            @logf.close
+            File.rename(@file_name, after_name)
+            do_compress(after_name) if @compress
+            prepare_logf
+
+            # sleep after rotation
+            sleep(@sleep_time) if @sleep_time > 0
+
+        rescue
+            SimpleRotate::Error.warning(SimpleRotate::Error::ROTATION_FAILED)
+            reopen if file_closed?
+        end
+    end
+
+    # compress rotated file
+    private
+    def do_compress(file)
+        contents = nil
+        File.open(file, File::RDONLY) do |f|
+            contents = f.read
+        end
+
+        newf = "#{file}.gz"
+
+        io = File.open(newf, File::WRONLY|File::CREAT|File::TRUNC)
+        Zlib::GzipWriter.wrap(io, @compress_level) do |writer|
+            writer.mtime     = File.mtime(file).to_i
+            writer.orig_name = file
+            writer.write(contents)
+        end
+
+        File.delete(file)
+    end
+
+    # convert 'limit_size' to integer
+    # @param  string|int $limit_size
+    # @return int
+    private
+    def trim_byte(limit)
+        return limit if limit.is_a?(Integer)
+
+        kiro = "000"
+        mega = kiro + "000"
+        giga = mega + "000"
+        tera = giga + "000"
+        limit_size = limit
+
+        if /K$/ =~ limit_size
+            limit_size = limit_size.sub(/K$/, "") + kiro
+        elsif  /M$/ =~ limit_size
+            limit_size = limit_size.sub(/M$/, "") + mega
+        elsif  /G$/ =~ limit_size
+            limit_size = limit_size.sub(/G$/, "") + giga
+        elsif  /T$/ =~ limit_size
+            limit_size = limit_size.sub(/T$/, "") + tera
+        end
+
+        return limit_size.to_i
+    end
+end