rb.rotate 0.1.0

data/lib/rb.rotate/state/file.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+require "rb.rotate/state"
+
+module RbRotate
+    module StateModule
+            
+        ##
+        # Represents file state record.
+        #
+        
+        class File
+
+            ##
+            # Holds the file data.
+            #
+            
+            @data
+            
+            ##
+            # Holds path of the appropriate file.
+            #
+            
+            @path
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(path, data)
+                @path = path
+                @data = data
+            end
+            
+            ##
+            # Indicates tate record for file exists.
+            #
+            
+            def exists?
+                not @data.empty?
+            end
+            
+            ##
+            # Returns last archival date.
+            #
+            
+            def date
+                @data[:date]
+            end
+            
+            ##
+            # Touches date to current date.
+            #
+            
+            def touch!
+                @data[:date] = Time::now
+            end
+            
+            ##
+            # Returns extension.
+            #
+            
+            def extension
+                @data[:filename][:extension]
+            end
+            
+            ##
+            # Returns basename.
+            #
+            
+            def name
+                @data[:filename][:name]
+            end
+            
+            ##
+            # Returns items list.
+            #
+            
+            def items
+                @data[:items]
+            end
+            
+            ##
+            # Returns directory specification.
+            #
+            
+            def directory
+                if @data.has_key? :directory 
+                    @data[:directory].to_sym
+                else
+                    nil
+                end
+            end
+            
+            ##
+            # Sets items list.
+            #
+            
+            def items=(value)
+                @data[:items].replace(value)
+            end
+            
+            ##
+            # Creates the state record.
+            #
+            
+            def create(file)
+                extension = ::File.extname(file.path)[1..-1]
+                if extension.nil?
+                    extension = nil
+                    cut = 0..-1
+                else
+                    cut = 0..-2
+                end
+                
+                new = {
+                    :date => Time::now,
+                    :items => { },
+                    :directory => file.directory.identifier,
+                    :filename => {
+                        :name => ::File.basename(file.path, extension.to_s)[cut],
+                        :extension => extension
+                    }
+                }
+                
+                @data.replace(new)
+            end
+            
+            ##
+            # Destroys the state record.
+            #
+            
+            def destroy!
+                State::files.delete(@path.to_sym)
+                @data = nil
+            end
+            
+        end
+    end
+end

data/lib/rb.rotate/storage.rb

@@ -0,0 +1,208 @@
+# encoding: utf-8
+
+require "rb.rotate/storage/entry"
+require "rb.rotate/file"
+require "rb.rotate/configuration"
+
+module RbRotate
+
+    ##
+    # Represents storage for archived files.
+    #
+    
+    class Storage
+
+        ##
+        # Directory for which storage is aimed.
+        #
+        
+        @directory
+        attr_reader :directory
+    
+        ##
+        # Constructor.
+        #
+        
+        def initialize(directory)
+            @directory = directory
+        end
+        
+        ##
+        # Alias for new.
+        #
+        
+        def self.get(directory)
+            self::new(directory)
+        end
+        
+        ##
+        # Creates storage according to file and puts it to it.
+        #
+        
+        def self.put(file)
+            self::get(file.directory).put(file)
+        end
+        
+        ##
+        # Puts file to storage.
+        #
+        
+        def put(file)
+            self.do_actions! file
+        end
+        
+        ##
+        # Indicates, storage is compressed.
+        #
+        
+        def compressed?
+            self.directory.compressable?
+        end
+        
+        ##
+        # Runs file actions.
+        #
+        
+        def do_actions!(file)
+            entry = StorageModule::Entry::new(self, file)
+        
+            # Loads them
+            actions = @directory.configuration[:action].split("+")
+            actions.map! do |i| 
+                i.strip!
+                k, v = i.split(":", 2)
+                [k.to_sym, v]
+            end
+            
+            # Does them
+            variables = { }
+            
+            actions.each do |action, arguments|
+                case action
+                    when :move, :copy, :append
+                        variables[:filepath] = entry.put! action
+                    when :remove
+                        variables[:filepath] = file.remove!
+                    when :create, :truncate
+                        variables[:filepath] = file.create!
+                    when :mail
+                        variables[:filepath] = entry.mail! arguments
+                    when :hook
+                        name, arguments = arguments.split(":", 2)
+                        variables.merge! Hook::new(name.to_sym, arguments, variables).run!
+                end
+            end
+        end
+        
+        ##
+        # Cleanups expired items from the storage.
+        #
+        
+        def cleanup!
+            self.each_entry do |entry|
+                entry.cleanup!
+            end
+        end
+        
+        ##
+        # Returns item identifier of the storage.
+        #
+        
+        def item_identifier
+            self.directory.configuration[:identifier]
+        end
+        
+        ##
+        # Indicates numeric identifier.
+        #
+        
+        def numeric_identifier?
+            self.item_identifier.to_sym == :numeric
+        end
+        
+        ##
+        # Removes orphans.
+        #
+        
+        def self.remove_orphans!
+            self::each_entry do |entry|
+                items_count = 0
+                
+                entry.each_item do |item|
+                    if item.expired?
+                        item.remove!
+                    elsif not item.exists?
+                        item.unregister!
+                    else
+                        items_count += 1
+                    end
+                end
+                
+                file = entry.file
+                if (not file.exists?) and (items_count <= 0)
+                    file.state.destroy!
+                end                    
+            end
+        end
+                
+        ##
+        # Traverses through each item in current storage.
+        #
+        
+        def each_item(&block)
+            self.each_entry do |entry|
+                entry.each_item(&block)
+            end
+        end
+                
+        ##
+        # Traverses through all entries of this directory storage.
+        #
+        
+        def each_entry
+            State::each_file do |path, state|
+                if state.directory == self.directory.identifier
+                    file = File::new(path)
+                    entry = StorageModule::Entry::new(self, file)
+                    
+                    yield entry
+                end
+            end
+        end
+        
+        ##
+        # Traverses through all items in global storage.
+        #
+        
+        def self.each_item(&block)
+            self.each_entry do |entry|
+                entry.each_item(&block)
+            end
+        end
+        
+        ##
+        # Traverses through all entries.
+        #
+        
+        def self.each_entry
+            State::each_file do |path, state|
+                file = File::new(path)
+                storage = self::new(file.directory)
+                entry = StorageModule::Entry::new(storage, file)
+                
+                yield entry
+            end
+        end
+        
+        ##
+        # Traverses through all directories in storage.
+        #
+        
+        def self.each_directory
+            Configuration::each_directory do |directory|
+                yield self::get(directory)
+            end
+        end
+        
+    end
+end

data/lib/rb.rotate/storage/entry.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require "rb.rotate/storage/item"
+require "rb.rotate/mail"
+
+module RbRotate
+    module StorageModule
+    
+        ##
+        # Represents an entry of the storage.
+        # Entry is archived items of one file.
+        #
+        
+        class Entry
+            
+            ##
+            # Holds file of the entry.
+            #
+            
+            @file
+            attr_reader :file
+            
+            ##
+            # Holds parent storage.
+            #
+            
+            @storage
+            attr_reader :storage
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(storage, file)
+                @storage = storage
+                @file = file
+            end
+            
+            ##
+            # Puts current version of the file to items.
+            #
+            
+            def put!(method)
+            
+                # If necessary, creates the state record
+                if not self.file.state.exists?
+                    self.file.state.create(@file)
+                end
+            
+                # Rotates other items
+                new_list = { }
+                self.each_item do |item|
+                    if item.exists?
+                        item.rotate!
+                        new_list[item.identifier] = item.path
+                    else
+                        item.unregister!
+                    end
+                end
+                
+                # Puts new item
+                item = Item::new(self).allocate(method)
+                new_list[item.identifier] = item.path
+                
+                self.file.state.touch!
+                self.file.state.items = new_list
+                
+                return self.file.path
+            end
+            
+            ##
+            # Cleanups the items.
+            #
+            
+            def cleanup!
+                self.each_item do |item|
+                    if item.expired?
+                        item.remove!
+                    end
+                end
+            end
+            
+            ##
+            # Mail file to specified address.
+            #
+            
+            def mail!(to)
+                if to.nil?
+                    to = @storage.directory.configuration[:mail]
+                end
+                if to.nil?
+                    raise Exception("No e-mail address specified for sending log to.")
+                end
+                
+                require "etc"
+                require "socket"
+
+                Mail::send(
+                    :from => Etc.getlogin.dup << "@" << Socket.gethostname,
+                    :to => to,
+                    :subject => Socket.gethostname.dup << " : log : " << self.file.path,
+                    :body => ::File.read(self.file.path)
+                )
+                
+                return self.file.path
+            end
+            
+            ##
+            # Traverses through all items.
+            #
+            
+            def each_item
+                self.file.state.items.each_pair do |identifier, path|
+                    yield Item::new(self, identifier, path)
+                end
+            end
+            
+        end
+    end
+end