backup 1.3.4 → 2.0.0

data/lib/backup/record/s3.rb

@@ -0,0 +1,90 @@
+module Backup
+  module Record
+    class S3 < ActiveRecord::Base
+        
+      # Establishes a connection with the SQLite3
+      # local database to avoid conflict with users
+      # Production database.
+      # establish_connection(
+      #  :adapter  => "sqlite3",
+      #  :database => "db/backup.sqlite3",
+      #  :pool     => 5,
+      #  :timeout  => 5000 )
+      
+      set_table_name 'backup_s3'
+      
+      # Scopes
+      default_scope :order => 'created_at desc'
+      
+      # Callbacks
+      after_save :clean_backups
+      
+      # Attributes
+      attr_accessor :adapter_config, :keep_backups
+      
+      # Receives the options hash and stores it
+      # Sets the S3 values
+      def load_adapter(adapter)
+        self.adapter_config = adapter
+        self.trigger        = adapter.procedure.trigger
+        self.adapter        = adapter.procedure.adapter_name
+        self.filename       = adapter.final_file
+        self.bucket         = adapter.procedure.get_storage_configuration.attributes['bucket']
+        self.keep_backups   = adapter.procedure.attributes['keep_backups']
+      end
+      
+      # Destroys all backups for the specified trigger from Amazon S3
+      def self.destroy_all_backups(procedure, trigger)
+        backups = Backup::Record::S3.all(:conditions => {:trigger => trigger})        
+        unless backups.empty?
+          s3 = Backup::Connection::S3.new
+          s3.static_initialize(procedure)
+          s3.connect
+          backups.each do |backup|
+            puts "\nDestroying backup \"#{backup.filename}\" from bucket \"#{backup.bucket}\"."
+            s3.destroy(backup.filename, backup.bucket)
+            backup.destroy
+          end
+          puts "\nAll \"#{trigger}\" backups destroyed.\n\n"
+        end
+      end
+      
+      private
+        
+        # Maintains the backup file amount on S3
+        # This is invoked after a successful record save
+        # This deletes the oldest files when the backup limit has been exceeded
+        def clean_backups
+          if keep_backups.is_a?(Integer)
+            backups = Backup::Record::S3.all(:conditions => {:trigger => trigger})
+            backups_to_destroy = Array.new
+            backups.each_with_index do |backup, index|
+              if index >= keep_backups then
+                backups_to_destroy << backup
+              end
+            end
+            
+            unless backups_to_destroy.empty?
+              
+              # Create a new Amazon S3 Object
+              s3 = Backup::Connection::S3.new(adapter_config)
+            
+              # Connect to Amazon S3 with provided credentials
+              s3.connect
+            
+              # Loop through all backups that should be destroyed and remove them from S3.
+              backups_to_destroy.each do |backup|
+                puts "\nDestroying backup \"#{backup.filename}\" from bucket \"#{backup.bucket}\"."
+                s3.destroy(backup.filename, backup.bucket)
+                backup.destroy
+              end
+              
+              puts "\nBackup storage for \"#{trigger}\" is limited to #{keep_backups} backups."
+              puts "\nThe #{keep_backups} most recent backups are now stored on S3.\n\n"
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/scp.rb

@@ -0,0 +1,92 @@
+module Backup
+  module Record
+    class SCP < ActiveRecord::Base
+        
+      # Establishes a connection with the SQLite3
+      # local database to avoid conflict with users
+      # Production database.
+      # establish_connection(
+      #  :adapter  => "sqlite3",
+      #  :database => "db/backup.sqlite3",
+      #  :pool     => 5,
+      #  :timeout  => 5000 )
+      
+      set_table_name 'backup_scp'
+      
+      # Scopes
+      default_scope :order => 'created_at desc'
+      
+      # Callbacks
+      after_save :clean_backups
+      
+      # Attributes
+      attr_accessor :adapter_config, :keep_backups, :ip, :user, :password
+      
+      # Receives the options hash and stores it
+      # Sets the SCP values
+      def load_adapter(adapter)
+        self.adapter_config = adapter
+        self.trigger        = adapter.procedure.trigger
+        self.adapter        = adapter.procedure.adapter_name
+        self.filename       = adapter.final_file
+        self.keep_backups   = adapter.procedure.attributes['keep_backups']
+        
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      # Destroys all backups for the specified trigger from Remote Server (SCP)
+      def self.destroy_all_backups(procedure, trigger)
+        backups = Backup::Record::SCP.all(:conditions => {:trigger => trigger})        
+        unless backups.empty?
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+          
+          Net::SSH.start(ip, user, :password => password) do |ssh|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              ssh.exec("rm #{File.join(backup.path, backup.filename)}")
+              backup.destroy
+            end
+          end
+         puts "\nAll \"#{trigger}\" backups destroyed.\n\n"
+        end
+      end
+      
+      private
+        
+        # Maintains the backup file amount on the remote server
+        # This is invoked after a successful record save 
+        # This deletes the oldest files when the backup limit has been exceeded
+        def clean_backups
+          if keep_backups.is_a?(Integer)
+            backups = Backup::Record::SCP.all(:conditions => {:trigger => trigger})
+            backups_to_destroy = Array.new
+            backups.each_with_index do |backup, index|
+              if index >= keep_backups then
+                backups_to_destroy << backup
+              end
+            end
+            
+            unless backups_to_destroy.empty?
+              
+              Net::SSH.start(ip, user, :password => password) do |ssh|
+                backups_to_destroy.each do |backup|
+                  puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+                  ssh.exec("rm #{File.join(backup.path, backup.filename)}")
+                  backup.destroy
+                end
+              end
+              
+              puts "\nBackup storage for \"#{trigger}\" is limited to #{keep_backups} backups."
+              puts "\nThe #{keep_backups} most recent backups are now stored on the remote server.\n\n"
+
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/storage/s3.rb

@@ -0,0 +1,14 @@
+module Backup
+  module Storage
+    class S3
+      
+      # Stores the file on the remote server using S3
+      def initialize(adapter)
+        s3 = Backup::Connection::S3.new(adapter)
+        s3.connect
+        s3.store
+      end
+      
+    end
+  end
+end

data/lib/backup/storage/scp.rb

@@ -0,0 +1,28 @@
+module Backup
+  module Storage
+    class SCP
+      
+      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
+      
+      # Stores the file on the remote server using SCP
+      def initialize(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+        
+        final_file = adapter.final_file
+        tmp_path   = adapter.tmp_path
+        
+        Net::SSH.start(ip, user, :password => password) do |ssh|
+          ssh.exec "mkdir -p #{path}"
+        end
+        
+        puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
+        Net::SCP.start(ip, user, :password => password) do |scp|
+          scp.upload! File.join(tmp_path, final_file).gsub('\ ', ' '), path
+        end
+      end
+      
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: backup
 version: !ruby/object:Gem::Version 
-  version: 1.3.4
+  version: 2.0.0
 platform: ruby
 authors: 
 - Michael van Rooijen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-08 00:00:00 +01:00
+date: 2009-12-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,17 +42,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.0.2
     version: 
-- !ruby/object:Gem::Dependency 
-  name: sqlite3-ruby
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.2.5
-    version: 
-description: "\n                          \xE2\x80\x9CBackup\xE2\x80\x9D is a RubyGem, written for Ruby on Rails. It's main purpose is to Backup any\n                          files to Amazon S3 or any remotely accessible server through SSH (SCP). It supports database\n                          and regular file backups. On top of that, it's extremely easy to set up. Backup will provide\n                          a generator script that will place all necessary files inside your Rails application.\n                          Two of which, are \xE2\x80\x9Cyaml\xE2\x80\x9D configuration files. Using just these two files to configure a\n                          backup for database formats such as a MySQL, SQLite3 or any Assets folder.\n                          Setting up \xE2\x80\x9CBackup\xE2\x80\x9D takes only about a minute or two!\n                        "
+description: "\n                          Backup is a Ruby Gem, written specifically for Ruby on Rails applications. This gem offers a quick and easy way\n                          to configure and run backups of your MySQL database (soon PostgreSQL and possibly more) and Archives (any files or folders)\n                          to \"Amazon S3\" or \"any remotely accessible server using SCP\". Backup handles: Compression, Archiving, Encryption and Backup Cleaning.\n                        "
 email: meskyan@gmail.com
 executables: []
 
@@ -69,30 +59,23 @@ files:
 - Rakefile
 - VERSION
 - backup.gemspec
-- generators/backup_files/backup_files_generator.rb
-- generators/backup_files/templates/backup.sqlite3
-- generators/backup_files/templates/config.rake
-- generators/backup_files/templates/db.rake
-- generators/backup_files/templates/s3.rake
-- generators/backup_files/templates/s3.yml
-- generators/backup_files/templates/setup.rake
-- generators/backup_files/templates/ssh.rake
-- generators/backup_files/templates/ssh.yml
+- generators/backup/backup_generator.rb
+- generators/backup/templates/config/backup.rb
+- generators/backup/templates/migrations/create_backup_tables.rb
+- generators/backup/templates/tasks/backup.rake
 - lib/backup.rb
-- lib/backup/adapter/assets.rb
-- lib/backup/adapter/custom.rb
-- lib/backup/adapter/mysql.rb
-- lib/backup/adapter/sqlite3.rb
-- lib/backup/backup_record/s3.rb
-- lib/backup/backup_record/ssh.rb
-- lib/backup/base.rb
-- lib/backup/connection/base.rb
+- lib/backup/adapters/archive.rb
+- lib/backup/adapters/base.rb
+- lib/backup/adapters/mysql.rb
+- lib/backup/configuration/adapter.rb
+- lib/backup/configuration/base.rb
+- lib/backup/configuration/helpers.rb
+- lib/backup/configuration/storage.rb
 - lib/backup/connection/s3.rb
-- lib/backup/connection/ssh.rb
-- lib/backup/encrypt.rb
-- lib/backup/transfer/base.rb
-- lib/backup/transfer/s3.rb
-- lib/backup/transfer/ssh.rb
+- lib/backup/record/s3.rb
+- lib/backup/record/scp.rb
+- lib/backup/storage/s3.rb
+- lib/backup/storage/scp.rb
 has_rdoc: true
 homepage: ""
 licenses: []

data/generators/backup_files/backup_files_generator.rb

@@ -1,72 +0,0 @@
-class BackupFilesGenerator < Rails::Generator::Base
-
-  # This method gets initialized when the generator gets run.
-  # It will receive an array of arguments inside @args
-  def initialize(runtime_args, runtime_options = {})
-    super
-    extract_args
-    set_defaults
-    confirm_input
-  end
-  
-  # Processes the file generation/templating
-  # This will automatically be run after the initialize method
-  def manifest
-    record do |m|
-      
-      # Generate the Rake Tasks
-      m.directory "lib/tasks"
-      m.directory "lib/tasks/backup"
-      m.directory "lib/tasks/backup/files"
-      m.file      "config.rake",    "lib/tasks/backup/config.rake"
-      m.file      "s3.rake",        "lib/tasks/backup/s3.rake"
-      m.file      "ssh.rake",       "lib/tasks/backup/ssh.rake"
-      m.file      "db.rake",        "lib/tasks/backup/db.rake"
-      m.file      "setup.rake",     "lib/tasks/backup/setup.rake"
-      m.file      "backup.sqlite3", "lib/tasks/backup/files/backup.sqlite3"
-      
-      # Generate the YAML files
-      m.directory "config/backup"
-      m.file      "s3.yml",       "config/backup/s3.yml"
-      m.file      "ssh.yml",      "config/backup/ssh.yml"
-      
-      # Generates the backup.sqlite3 database
-      m.directory "db"
-      m.file      "backup.sqlite3", "db/backup.sqlite3"
-      
-    end
-  end
-  
-  # Creates a new Hash Object containing the user input
-  # The user input will be available through @input and input
-  def extract_args
-    @input = Hash.new
-    @args.each do |arg|
-      if arg.include?(":") then
-        @input[:"#{arg.slice(0, arg.index(":"))}"] = arg.slice((arg.index(":") + 1)..-1)
-      end
-    end
-  end
-  
-  # Input Method that's available inside the generated templates
-  # because instance variable are not available, so we access them through methods
-  def input
-    @input
-  end
-
-  # Sets defaults for user input when left blank by the user
-  # for each parameter
-  def set_defaults
-  end
-  
-  # Confirms whether the model and attachment arguments were passed in
-  # Raises an error if not
-  def confirm_input
-  end
-  
-  private
-  
-  def input_error
-  end
-  
-end

data/generators/backup_files/templates/config.rake

@@ -1,20 +0,0 @@
-# Opens and Reads the Backup YAML File from the RAILS_ROOT/config/backup path
-# Replaces all the :rails_root tokens with the actual RAILS_ROOT path
-# Returns the content of the file in YAML format
-def read_backup_yaml_file(config_file)  
-  YAML.load File.open(File.join(RAILS_ROOT, 'config', 'backup', config_file), 'r').read.gsub(/:rails_root/, RAILS_ROOT)
-end
-
-namespace :backup do
-
-  task :s3_config => :environment do
-    @config   = read_backup_yaml_file('s3.yml')
-    @adapters = ['mysql', 'sqlite3', 'assets', 'custom']
-  end
-  
-  task :ssh_config => :environment do
-    @config   = read_backup_yaml_file('ssh.yml')
-    @adapters = ['mysql', 'sqlite3', 'assets', 'custom']
-  end
-  
-end

data/generators/backup_files/templates/db.rake

@@ -1,62 +0,0 @@
-namespace :backup do
-  namespace :db do
-    namespace :truncate do
-      
-      desc 'Truncates the S3 Backup database records; Physical files WILL NOT be deleted from S3.'
-      task :s3 => :environment do
-        puts "Truncating S3 Backup database records!"
-        Backup::BackupRecord::S3.destroy_all
-      end
-      
-      desc 'Truncates the SHH database records; Physical files WILL NOT be deleted from remote server.'
-      task :ssh => :environment do
-        puts "Truncating SSH database records!"
-        Backup::BackupRecord::SSH.destroy_all
-      end
-      
-    end
-
-
-    namespace :destroy do
-      
-      desc 'Destroys S3 Backup database records; Physical files WILL be deleted as well.'
-      task :s3 => :s3_config do
-        puts "Removing all backups from S3.."
-        @adapters.each do |adapter|
-          if @config[adapter]
-            unless @config[adapter].is_a?(Array)
-              puts "\n\n-- Processing #{adapter} backups --"
-              Backup::BackupRecord::S3.destroy_all_backups(adapter, @config[adapter], 0)
-            else
-              puts "\n\n-- Processing #{adapter} backups --"
-              @config[adapter].each_with_index do |config, index|
-                Backup::BackupRecord::S3.destroy_all_backups(adapter, config, index)  
-              end
-            end
-          end
-        end
-        puts "\n\nAll S3 backups destroyed!\n\n"
-      end
-      
-      desc 'Destroys SSH Backup database records; Physical files WILL be deleted as well.'
-      task :ssh => :ssh_config do
-        puts "Removing all backups from remote server through SSH.."
-        @adapters.each do |adapter|
-          if @config[adapter]
-            unless @config[adapter].is_a?(Array)
-              puts "\n\n-- Processing #{adapter} backups --"
-              Backup::BackupRecord::SSH.destroy_all_backups(adapter, @config[adapter], 0)
-            else
-              puts "\n\n-- Processing #{adapter} backups --"
-              @config[adapter].each_with_index do |config, index|
-                Backup::BackupRecord::SSH.destroy_all_backups(adapter, config, index)  
-              end
-            end
-          end
-        end
-        puts "\n\nAll backups from remote server destroyed!\n\n"
-      end
-      
-    end
-  end
-end