backup-gundua 2.3.1.1

data/lib/backup/record/scp.rb

@@ -0,0 +1,31 @@
+module Backup
+  module Record
+    class SCP < Backup::Record::Base
+
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          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
+        end
+        
+    end
+  end
+end

data/lib/backup/record/sftp.rb

@@ -0,0 +1,36 @@
+module Backup
+  module Record
+    class SFTP < Backup::Record::Base
+
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+          
+          Net::SFTP.start(ip, user, :password => password) do |sftp|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              begin
+                sftp.remove!(File.join(backup.path, backup.filename))
+                backup.destroy
+              rescue
+                puts "Could not find backup #{backup.path}/#{backup.filename}.."
+                backup.destroy
+              end
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/storage/ftp.rb

@@ -0,0 +1,36 @@
+module Backup
+  module Storage
+    class FTP
+      
+      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
+      
+      # Stores the backup file on the remote server using FTP
+      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::FTP.open(ip, user, password) do |ftp|
+          begin
+            ftp.chdir(path)
+          rescue
+            puts "Could not find or access \"#{path}\" on \"#{ip}\", please ensure this directory exists and is accessible by the user \"#{user}\"."
+            exit
+          end
+          
+          begin
+            puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
+            ftp.putbinaryfile(File.join(tmp_path, final_file).gsub('\ ', ' '), File.join(path, final_file))
+          rescue
+            puts "Could not save file to backup server. Is the \"#{path}\" directory writable?"
+            exit
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/backup/storage/local.rb

@@ -0,0 +1,24 @@
+module Backup
+  module Storage
+    class Local
+      
+      include Backup::CommandHelper
+      
+      # Store on same machine, preferentially in a different hard drive or in 
+      # a mounted network path (NFS, Samba, etc)
+      attr_accessor :path, :tmp_path, :final_file
+      
+      # Stores the backup file on local machine
+      def initialize(adapter)
+        self.path = adapter.procedure.get_storage_configuration.attributes['path']
+        self.tmp_path   = adapter.tmp_path
+        self.final_file = adapter.final_file
+        
+        run "mkdir -p #{path}"
+        run "cp #{File.join(tmp_path, final_file).gsub('\ ', ' ')} #{File.join(path, final_file)}"
+      end
+      
+    end
+  end
+end
+

data/lib/backup/storage/s3.rb

@@ -0,0 +1,14 @@
+module Backup
+  module Storage
+    class S3
+      
+      # Stores the backup 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 backup 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

data/lib/backup/storage/sftp.rb

@@ -0,0 +1,29 @@
+module Backup
+  module Storage
+    class SFTP
+      
+      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
+      
+      # Stores the backup file on the remote server using SFTP
+      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::SFTP.start(ip, user, :password => password) do |sftp|
+          begin
+            puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
+            sftp.upload!(File.join(tmp_path, final_file).gsub('\ ', ' '), File.join(path, final_file))
+          rescue
+            puts "Could not find \"#{path}\" on \"#{ip}\", please ensure this directory exists."
+            exit
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/backup.rb

@@ -0,0 +1,118 @@
+# Load Gems
+require 'net/ssh'
+require 'net/scp'
+require 'net/ftp'
+require 'net/sftp'
+require 'aws/s3'
+require 'pony'
+require 'hirb'
+
+# Load Environments
+require 'backup/environment/base'
+require 'backup/environment/unix'
+require 'backup/environment/rails'
+
+# Load Configuration
+require 'backup/configuration/attributes'
+require 'backup/configuration/base'
+require 'backup/configuration/adapter'
+require 'backup/configuration/adapter_options'
+require 'backup/configuration/storage'
+require 'backup/configuration/mail'
+require 'backup/configuration/smtp'
+require 'backup/configuration/helpers'
+
+require 'backup/command_helper'
+
+# Include the Configuration and Environment Helpers
+include Backup::Configuration::Helpers
+include Backup::Environment::Base
+
+# Load either UNIX or RAILS environment configuration
+case current_environment
+  when :unix  then include Backup::Environment::Unix
+  when :rails then include Backup::Environment::Rails
+end
+
+# Load configuration
+if File.exist?(File.join(BACKUP_PATH, 'config', 'backup.rb'))
+  require File.join(BACKUP_PATH, 'config', 'backup.rb')
+end
+
+# Load Mail Notifier
+require 'backup/mail/base'
+
+# Set Mail Configuration (extracted from the backup.rb configuration file) inside the Mail Class
+Backup::Mail::Base.setup(@mail_configuration)
+
+# Load Adapters
+require 'backup/adapters/base'
+require 'backup/adapters/mysql'
+require 'backup/adapters/sqlite'
+require 'backup/adapters/postgresql'
+require 'backup/adapters/archive'
+require 'backup/adapters/custom'
+
+# Load Connectors
+require 'backup/connection/s3'
+
+# Load Storage
+require 'backup/storage/s3'
+require 'backup/storage/scp'
+require 'backup/storage/ftp'
+require 'backup/storage/sftp'
+require 'backup/storage/local'
+
+# Backup Recorders
+require 'backup/record/base'
+require 'backup/record/s3'
+require 'backup/record/scp'
+require 'backup/record/ftp'
+require 'backup/record/sftp'
+require 'backup/record/local'
+
+# Backup Module
+module Backup
+  class Setup
+  
+    attr_accessor :trigger, :procedures, :procedure
+    
+    # Sets the Trigger and All Available Procedures.
+    # Will not find a specific procedure if the "trigger" argument is set to false.
+    def initialize(trigger, procedures)
+      self.trigger    = trigger
+      self.procedures = procedures
+      self.procedure  = find_triggered_procedure unless trigger.eql?(false)
+    end
+    
+    # Initializes one of the few adapters and start the backup process
+    def initialize_adapter
+      case procedure.adapter_name.to_sym
+        when :mysql       then Backup::Adapters::MySQL.new      trigger, procedure
+        when :sqlite      then Backup::Adapters::SQLite.new     trigger, procedure
+        when :postgresql  then Backup::Adapters::PostgreSQL.new trigger, procedure
+        when :archive     then Backup::Adapters::Archive.new    trigger, procedure
+        when :custom      then Backup::Adapters::Custom.new     trigger, procedure
+        else
+          puts "Unknown Adapter: \"#{procedure.adapter_name}\"."
+          exit
+      end
+    end
+  
+    # Scans through all the backup settings and returns the backup setting
+    # that was specified in the "trigger" argument.
+    # If an non-existing trigger is specified, it will raise an error and display
+    # all the available triggers.
+    def find_triggered_procedure
+      procedures.each do |procedure|
+        if procedure.trigger.eql?(trigger)
+          return procedure
+        end
+      end
+      available_triggers = procedures.map {|procedure| "- #{procedure.trigger}\n" }
+      puts "Could not find a backup procedure with the trigger \"#{trigger}\". \nHere's a list of available triggers:\n#{available_triggers}"
+      exit
+    end
+
+  end
+end

data/setup/backup.rb

@@ -0,0 +1,202 @@
+# Backup Configuration File
+# 
+# Use the "backup" block to add backup settings to the configuration file.
+# The argument before the "do" in (backup "argument" do) is called a "trigger".
+# This acts as the identifier for the configuration.
+#
+# In the example below we have a "mysql-backup-s3" trigger for the backup setting.
+# All the configuration is done inside this block. To initialize the backup process for this block,
+# you invoke it using the following command:
+#
+#   backup --run mysql-backup-s3
+# 
+# You can add as many backup block settings as you want, just be sure every trigger is unique and you can run
+# each of them separately.
+# 
+# ADAPTERS
+#  - MySQL
+#  - PostgreSQL
+#  - SQLite
+#  - Archive
+#  - Custom
+#
+# STORAGE METHODS
+#  - S3     (Amazon)
+#  - SCP    (Remote Server)
+#  - FTP    (Remote Server)
+#  - SFTP   (Remote Server)
+#  - LOCAL  (Local Server)
+#
+# GLOBAL OPTIONS
+#  - Keep Backups (keep_backups)
+#  - Encrypt With Pasword (encrypt_with_password)
+#  - Notify (notify)
+#
+#  This is the "decrypt" command for all encrypted backups:
+#    sudo backup --decrypt /path/to/encrypted/file
+#
+# Each Backup Setting can contain:
+# - 1 Adapter
+# - 1 Storage Method
+# - Multiple Global Options
+#
+# The combination of these, however, do not matter! So experiment with it.
+# 
+# You can also let Backup notify you by email on successfully created backups.
+# - Just uncomment the block of code below (notifier_settings) and fill in your credentials.
+# - Then for set "notify" to "true" in each (backup) block you wish to be notified of.
+#
+# For more information on "Backup", please refer to the wiki on github
+#   http://wiki.github.com/meskyanichi/backup/configuration-file
+
+
+# Notifier
+#   Uncomment this if you want to enable notification by email on successful backup runs
+#   You will also have to set "notify true" inside each backup block below to enable it for that particular backup
+# notifier_settings do
+#   
+#   to    "example1@gmail.com"
+#   from  "example2@gmail.com"
+#   
+#   smtp do
+#     host            "smtp.gmail.com"
+#     port            "587"
+#     username        "example1@gmail.com"
+#     password        "example1password"
+#     authentication  "plain"
+#     domain          "localhost.localdomain"
+#     tls             true
+#   end
+# 
+# end
+
+
+# Initialize with:
+#  sudo backup --run mysql-backup-s3
+backup 'mysql-backup-s3' do
+  
+  adapter :mysql do
+    user        'user'
+    password    'password'
+    database    'database'
+  
+    # skip_tables ['table1', 'table2', 'table3']
+    # 
+    # options do
+    #   host    '123.45.678.90'
+    #   port    '80'
+    #   socket  '/tmp/socket.sock'
+    # end
+    # additional_options '--single-transaction  --quick'
+  end
+  
+  storage :s3 do
+    access_key_id     'access_key_id'
+    secret_access_key 'secret_access_key'
+    bucket            '/bucket/backups/mysql/'
+    use_ssl           true
+  end
+  
+  keep_backups 25
+  encrypt_with_password 'password'
+  notify false
+  
+end
+
+
+# Initialize with:
+#  sudo backup --run postgresql-backup-s3
+backup 'postgresql-backup-scp' do
+  
+  adapter :postgresql do
+    user      'user'
+    database  'database'
+
+    # skip_tables ['table1', 'table2', 'table3']
+  
+    # options do
+    #   host    '123.45.678.90'
+    #   port    '80'
+    #   socket  '/tmp/socket.sock'
+    # end
+    # additional_options '--clean --blobs'
+  end
+  
+  storage :scp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/postgresql/'
+  end
+
+  keep_backups :all
+  encrypt_with_password false
+  notify false
+  
+end
+
+
+# Initialize with:
+#   sudo backup --run archive-backup-ftp
+backup 'archive-backup-ftp' do
+  
+  adapter :archive do
+    files ["/path/to/log", "/path/to/db"]
+  end
+  
+  storage :ftp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/archive/'
+  end
+
+  keep_backups 10
+  encrypt_with_password false
+  notify false
+  
+end
+
+
+# Initialize with:
+#   sudo backup --run custom-backup-sftp
+backup 'custom-backup-sftp' do
+  
+  adapter :custom do
+    commands \
+      [ "mysqldump            [options] [database] > :tmp_path/my_mysql_dump.sql",
+        "pg_dump              [options] [database] > :tmp_path/my_postgresql_dump.sql",
+        "any_other_db_format  [options] [database] > :tmp_path/my_any_other_db_format.sql" ]
+  end
+  
+  storage :sftp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/custom/'
+  end
+
+  keep_backups :all
+  encrypt_with_password 'password'
+  notify false
+
+end
+
+
+# Initializ with:
+#   sudo backup --run sqlite-backup-local
+backup 'sqlite-backup-local' do
+  
+  adapter :sqlite do
+    database "/path/to/database.sqlite3"
+  end
+  
+  storage :local do
+    path "/path/to/storage/location/"
+  end
+  
+  keep_backups :all
+  encrypt_with_password false
+  notify false
+  
+end

data/spec/configuration/attributes_spec.rb

@@ -0,0 +1,35 @@
+require 'backup/configuration/attributes'
+
+describe Backup::Configuration::Attributes do
+  before(:all) do
+    class ConfigurationSample
+      extend Backup::Configuration::Attributes
+      generate_attributes :file, :username, :password
+    end
+    @sample = ConfigurationSample.new
+  end
+  
+  it "should generate setter methods to attributes" do
+    @sample.should respond_to(:file)
+    @sample.should respond_to(:username)
+    @sample.should respond_to(:password)
+  end
+  
+  it "should generate accessor for attributes" do
+    @sample.should respond_to(:attributes)
+  end
+  
+  it "should store keys of attributes as strings" do
+    @sample.file "list.txt"
+    @sample.username "jonh"
+    @sample.password "secret"
+    @sample.attributes.keys.all? {|k| k.is_a?(String)}.should == true
+  end
+  
+  it "should store values of attributes in attributes hash" do
+    @sample.file "list.txt"
+    @sample.attributes.keys.should include('file')
+    @sample.attributes['file'].should == "list.txt"
+  end
+end
+