rb.rotate 0.1.0

data/lib/rb.rotate/directory.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+require "rb.rotate/configuration"
+require "rb.rotate/file"
+require "rb.rotate/reader"
+require "rb.rotate/storage"
+
+module RbRotate
+
+    ##
+    # Represents one log directory.
+    #
+    
+    class Directory
+        
+        ##
+        # Internal cache of the configuration.
+        #
+        
+        @configuration
+        
+        ##
+        # Parent configuration object.
+        #
+        
+        @parent
+        
+        ##
+        # Indicates, it isn't child directory of configured directory,
+        # but directly the configured directory.
+        #
+        
+        @configured 
+        
+        ##
+        # Holds directory identifier.
+        #
+        
+        @identifier
+        attr_reader :identifier
+        
+        ##
+        # Holds directory path.
+        #
+        
+        @path
+        attr_reader :path
+        
+        ##
+        # Constructor.
+        # 
+        # Identifier is symbol so identifier in configuration file or
+        # string, so directory path.
+        #
+        
+        def initialize(identifier, parent = nil)
+            @parent = parent
+            if identifier.kind_of? Symbol
+                @identifier = identifier
+            else
+                @path = identifier
+            end
+        end
+    
+        ##
+        # Returns the configuration instance.
+        #
+        
+        def configuration
+            if @configuration.nil?
+                # If no identifier set, looks for the dir 
+                #  in configuration.
+                if @identifier.nil?
+                    directory = Configuration::find_path(@path)
+                    
+                    if not directory.nil?
+                        @identifier = directory.identifier
+                        @configured = true
+                    elsif not @parent.nil?
+                        @identifier = @parent.identifier
+                        @configured = false
+                    else
+                        @identifier = :default
+                        @configured = false
+                    end
+                else
+                    @configured = true
+                end
+                
+                @configuration = DirectoryConfiguration::new(@identifier)
+            end
+            
+            return @configuration
+        end
+        
+        ##
+        # Indicates, it isn't child directory of configured directory,
+        # but directly the configured directory.
+        #
+        
+        def configured?
+            self.configuration
+            @configured
+        end
+        
+        ##
+        # Returns path to directory.
+        #
+        # So it get @path or directory from configuration if hasn't 
+        # been sete.
+        #
+        
+        def path
+            if not @path.nil?
+                @path
+            else
+                self.configuration.directory
+            end
+        end
+        
+        ##
+        # Returns relative path to parent (configured) directory.
+        #
+        
+        def relative_path
+            if self.configured?
+                "."
+            else
+                self.path[(self.configured_ancestor.path.length + 1)..-1]
+            end
+        end
+        
+        ##
+        # Returns the "nearest" configured ancestor.
+        #
+        
+        def configured_ancestor
+            if self.configured?
+                self
+            elsif not @parent.nil?
+                @parent.configured_ancestor
+            else
+                nil
+            end
+        end
+        
+        ##
+        # Traverses through all files in directory.
+        #
+        
+        def each_file(&block)
+            Reader::read(self, :filter => :files, &block)
+        end
+
+        ##
+        # Traverses through all directories in directory.
+        #
+        
+        def each_directory(&block)
+            Reader::read(self, :filter => :dirs, &block)
+        end
+        
+        ##
+        # Rotates.
+        #
+        
+        def rotate!
+            # Cleans old or expired items
+            # self.storage.cleanup! (cleaned up globally by dispatcher call)
+            
+            # Rotates
+            if self.configuration[:recursive]
+                self.each_directory do |directory|
+                    directory.rotate!
+                end
+            end
+            self.each_file do |file|
+                file.rotate!
+            end
+        end        
+        
+        ##
+        # Indicates, directory entries should be compressed 
+        # in archive.
+        #
+        
+        def compressable?
+            not self.configuration[:compress].nil?
+        end
+        
+        ##
+        # Returns storage appropriate to directory.
+        #
+        
+        def storage
+            Storage::get(self)
+        end
+        
+    end
+    
+end

data/lib/rb.rotate/dispatcher.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module RbRotate
+
+    ##
+    # Dispatches all operations.
+    #
+    
+    class Dispatcher
+        
+        ##
+        # Runs the rotate session.
+        #
+        
+        def run!
+            require "rb.rotate/configuration"
+            require "rb.rotate/state"
+            require "rb.rotate/storage"
+            require "rb.rotate/log"
+
+            # Reads configuration file
+            locator = ::File.dirname(::File.dirname(__FILE__)).dup << "/paths.conf"
+            if not ::File.exists? locator
+                STDERR.write("FATAL: rb.rotate unconfigured. Please, run 'rb.rotate install' or eventually create the " << locator << " file with path to configuration file. Aborted.\n")
+                exit
+            end
+            
+            path = ::File.read(locator)
+            path.strip!
+            
+            Configuration::read(path)
+            log "Configuration file loaded."
+            
+            # Process
+            log "Start of processing."
+            Configuration::each_directory do |directory|
+                begin
+                    directory.rotate!
+                rescue Exception => e
+                    log "Exception: " << e.to_s
+                end
+            end
+            
+            # Removes orhpans
+            log "Start of orphans removing."
+            Storage::remove_orphans!
+            
+            # Saves state file
+            State::save!
+            log "New state saved."
+        end
+        
+        ##
+        # Installs the application configuration files.
+        #
+        
+        def install!
+            require "sys/uname"
+            require "fileutils"
+            
+            basedir = ::File.dirname(__FILE__)
+            
+            # Loads and creates the configuration dir
+            case Sys::Uname.sysname.downcase.to_sym
+                when :freebsd
+                    etc = "/usr/local/etc"
+                when :linux
+                    etc = "/etc"
+                else
+                    raise Exception::new("You are running on an unknown platform. It cannot be problem, but it's necessary define path to configuration file and define paths in configuration file.")
+            end
+            
+            etc << "/rb.rotate"
+            FileUtils.mkdir_p(etc)
+            
+            # Creates other important directories
+            FileUtils.mkdir_p("/var/log")
+            FileUtils.mkdir_p("/var/lib")
+            
+            # Puts configuration files to configuration directory
+            source = basedir.dup << "/install"
+            replacements = { "%%configuration" => etc }
+            files = ["rotate.yaml", "defaults.yaml"]
+            
+            files.each do |file|
+                body = ::File.read(source.dup << "/" << file << ".initial")
+                replacements.each_pair do |key, value|
+                    body.gsub! key, value
+                end
+                ::File.open(etc.dup << "/" << file, "w") do |io|
+                    io.write(body)
+                end
+            end
+            
+            # Puts to library root path path to configuration directory
+            ::File.open(basedir.dup << "/../paths.conf", "w") do |io|
+                io.write(etc.dup << "/rotate.yaml")
+            end
+        end
+        
+        ##
+        # Prints out system name.
+        #
+        
+        def sysname!
+            require "sys/uname"
+            puts Sys::Uname.sysname.downcase
+        end
+        
+    end    
+    
+end

data/lib/rb.rotate/file.rb

@@ -0,0 +1,174 @@
+# encoding: utf-8
+
+require "fileutils"
+require "rb.rotate/storage"
+require "rb.rotate/directory"
+require "rb.rotate/configuration"
+
+module RbRotate
+
+    ##
+    # Represents one log file.
+    #
+    
+    class File
+    
+        ##
+        # Holds parent file directory.
+        #
+        
+        @directory
+        
+        ##
+        # Indicates file path.
+        #
+        
+        @path
+        attr_reader :path
+        
+        ##
+        # Holds state for the file.
+        #
+        
+        @state
+        
+        ##
+        # Holds stat informations about the (original) file.
+        #
+        
+        @stat
+        
+        ##
+        # Constructor.
+        #
+        
+        def initialize(path, directory = nil)
+            @directory = directory
+            @path = path
+            @stat = ::File.stat(@path.to_s)
+        end
+        
+        ##
+        # Returns the file parent directory object.
+        #
+        
+        def directory
+            if @directory.nil?
+                if not self.state.directory.nil?
+                    @directory = Directory::new(self.state.directory)
+                else
+                    @directory = Configuration::find_path(::File.dirname(@path.to_s))
+                end
+                    
+                if @directory.nil?
+                    raise Exception::new("File from directory which isn't covered by rb.rotate found: " << @path.to_s  << ".")
+                end
+            end
+            
+            return @directory
+        end
+        
+        ##
+        # Removes the file from medium.
+        #
+        
+        def remove!
+            FileUtils.remove_file(@path)
+            return @path
+        end
+        
+        ##
+        # Creates new file.
+        #
+        
+        def create!
+            ::File.open(@path, "w").close()
+            
+            # Sets access rights and ownership according to 
+            # stat information
+            if not @stat.nil?
+                ::FileUtils.chmod(@stat.mode, @path)
+                ::FileUtils.chown(@stat.uid, @stat.gid, @path)
+            end
+            
+            return @path
+        end
+        
+        ##
+        # Truncates file.
+        #
+        
+        alias :"truncate!" :"create!"
+        
+        ##
+        # Rotates the file.
+        #
+        
+        def rotate!
+            if self.archivable?
+                self.archive!
+            end
+        end
+        
+        ##
+        # Archives file.
+        #
+        
+        def archive!
+            Storage::put(self)
+        end
+        
+        ##
+        # Indicates, file is suitable for immediate archiving.
+        #
+        
+        def archivable?
+            self.too_big? or self.too_old?
+        end
+        
+        ##
+        # Indicates, file is bigger than is allowed.
+        #
+        
+        def too_big?
+            ::File.size(@path) > @directory.configuration[:"max size"].to_bytes 
+        end
+        
+        ##
+        # Indicates, file is too old.
+        #
+        
+        def too_old?
+            if self.state.exists?
+                period = @directory.configuration[:period].to_seconds
+                result = Time::at(self.state.date + period) < Time::now
+            else
+                result = false
+            end
+            
+            return result
+        end
+        
+        ##
+        # Returns state.
+        #
+        
+        def state
+            if @state.nil?
+                @state = State::get.file(@path)
+            end
+            
+            return @state
+        end
+        
+        ##
+        # Indicates file exists.
+        #
+        
+        def exists?
+            ::File.exists? @path.to_s
+        end
+        
+    end
+    
+end