siba 0.4.3

data/lib/siba/plugins/destination/dir/dest_dir.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module Siba::Destination
+  module Dir 
+    class DestDir
+      include Siba::FilePlug
+      include Siba::LoggerPlug
+      attr_accessor :dir
+
+      def initialize(dir)
+        @dir = siba_file.file_expand_path dir
+        test_dir_access
+      end
+
+      def copy_backup_to_dest(path_to_backup)
+        siba_file.run_this "copy backup to dest" do
+          logger.info "Copying backup to destination directory: #{dir}"
+          unless siba_file.file_file? path_to_backup
+            raise Siba::Error, "Backup file '#{path_to_backup}' does not exist"
+          end
+          unless siba_file.file_directory? dir
+            raise Siba::Error, "Destination directory '#{dir}' does not exist" 
+          end
+          siba_file.file_utils_cp(path_to_backup, dir) 
+        end
+      end
+
+      def restore_backup_to_dir(backup_name, to_dir)
+        siba_file.run_this do
+          logger.info "Copying backup from destination directory: #{dir}"
+          path_to_backup = File.join dir, backup_name
+          unless siba_file.file_file? path_to_backup
+            raise Siba::Error, "Can not find backup #{path_to_backup}"
+          end
+
+          siba_file.file_utils_cp path_to_backup, to_dir
+        end
+      end
+      
+      def test_dir_access
+        siba_file.run_this "test dir access" do
+          # create dest dir
+          begin
+            siba_file.file_utils_mkpath dir unless siba_file.file_directory? dir
+          rescue Exception
+            logger.error "Failed to create destination dir '#{dir}'."
+            raise
+          end
+
+          # copy a test file to dest dir
+          begin          
+            test_file = Siba::TestFiles.prepare_test_file "destination_dir", dir
+            raise "Can not find the test file." unless siba_file.file_file? test_file
+            siba_file.file_utils_remove_entry_secure test_file
+          rescue Exception
+            logger.error "Could not write to destination dir '#{dir}'"
+            raise
+          end
+
+          logger.debug "Access to destination directory is verified"
+        end
+      end
+
+      # Returns an array of two-element arrays: [file_name, mtime]
+      def get_backups_list(backup_name)
+        siba_file.run_this do
+          Siba::FileHelper.entries(dir).select do |f|
+            f =~ /^#{backup_name}/
+          end.map do |f| 
+            mtime = siba_file.file_mtime File.join dir, f
+            [f, mtime]
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/siba/plugins/destination/dir/init.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require 'siba/plugins/destination/dir/dest_dir'
+
+module Siba::Destination
+  module Dir 
+    class Init 
+      attr_accessor :dest_dir
+
+      def initialize(options)
+        dir = Siba::SibaCheck.options_string options, "dir"
+        @dest_dir = Siba::Destination::Dir::DestDir.new dir
+      end
+
+      def backup(path_to_backup_file)
+        @dest_dir.copy_backup_to_dest path_to_backup_file
+      end
+
+      # Put backup file into dir
+      def restore(backup_name, dir)
+        @dest_dir.restore_backup_to_dir backup_name, dir
+      end
+
+      # Returns an array of two-element arrays:
+      # [backup_file_name, modification_time]
+      def get_backups_list(backup_name)
+        @dest_dir.get_backups_list backup_name
+      end
+    end
+  end
+end

data/lib/siba/plugins/destination/dir/options.yml

@@ -0,0 +1,2 @@
+dir: destination_dir # relative to this options file
+# or /absolute or ~/relative_to_home

data/lib/siba/plugins/encryption/gpg/encryption.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+
+module Siba::Encryption
+  module Gpg
+    class Encryption 
+      include Siba::LoggerPlug
+      include Siba::FilePlug
+
+      DEFAULT_CIPHER = "AES256"      
+
+      attr_accessor :passphrase, :cipher
+
+      def initialize(passphrase, cipher=DEFAULT_CIPHER)
+        @passphrase = passphrase
+        @cipher = Encryption.check_cipher cipher
+        check_password_strength
+        test_encryption
+      end
+
+      def encrypt(path_to_archive)
+        path_to_encrypted_backup = "#{path_to_archive}.gpg"
+        siba_file.run_this("encrypt") do
+          if siba_file.file_file? path_to_encrypted_backup
+            raise Siba::Error, "Encrypted file #{path_to_encrypted_backup} already exists" 
+          end
+          passphare_for_command = passphrase.gsub('"','\\"')
+          gpg_homedir = Siba::TestFiles.mkdir_in_tmp_dir "gpg-homedir"
+          command_without_password = %(gpg -c -q --batch --homedir="#{gpg_homedir}" --no-options --cipher-algo=#{cipher} --passphrase="****" --no-use-agent "#{path_to_archive}")
+          command = command_without_password.gsub "****", passphare_for_command
+          siba_file.run_shell command, "failed to encrypt: #{command_without_password}"
+          unless siba_file.file_file? path_to_encrypted_backup
+            raise siba::error, "failed to find encrypted backup file: #{command_without_password}" 
+          end
+        end
+        path_to_encrypted_backup 
+      end
+
+      def decrypt(path_to_encrypted_file, path_to_decrypted_file=nil)
+        path_to_decrypted_file = path_to_encrypted_file.gsub /\.gpg$/, "" if path_to_decrypted_file.nil?
+        siba_file.run_this("decrypt") do
+          if siba_file.file_file? path_to_decrypted_file
+            raise Siba::Error, "Decrypted file #{path_to_decrypted_file} already exists" 
+          end
+          passphare_for_command = passphrase.gsub('"','\\"')
+          gpg_homedir = Siba::TestFiles.mkdir_in_tmp_dir "gpg-homedir"
+          command_without_password = %(gpg -d -q --batch --homedir="#{gpg_homedir}" --no-options --passphrase="****" -o "#{path_to_decrypted_file}" --no-use-agent "#{path_to_encrypted_file}")
+          command = command_without_password.gsub "****", passphare_for_command
+          siba_file.run_shell command, "failed to decrypt: #{command_without_password}"
+          unless siba_file.file_file? path_to_decrypted_file
+            raise siba::error, "failed to find decrypted backup file: #{command_without_password}" 
+          end
+        end
+        path_to_decrypted_file
+      end
+
+      def test_encryption
+        begin
+          siba_file.run_this("test_encryption") do
+            # encrypt
+            path_to_source_file = Siba::TestFiles.prepare_test_file "encryption-gpg"
+            path_to_encrypted_file = encrypt path_to_source_file
+            raise unless path_to_encrypted_file == "#{path_to_source_file}.gpg"
+            raise unless siba_file.file_file? path_to_encrypted_file
+            raise if siba_file.file_utils_compare_file path_to_source_file, path_to_encrypted_file
+
+            # decrypt
+            path_to_output_file = "#{path_to_source_file}.decrypted"
+            path_to_decrypted_file = decrypt path_to_encrypted_file, path_to_output_file
+            raise unless path_to_decrypted_file == path_to_output_file
+            raise unless siba_file.file_utils_compare_file path_to_source_file, path_to_decrypted_file
+
+            logger.debug "GPG encryption is verified"
+          end
+        rescue Exception
+          logger.error "'gpg' encryption utility does not work correctly. Try reinstalling it."
+          raise
+        end
+      end
+
+      class << self
+        include Siba::FilePlug
+        include Siba::LoggerPlug
+
+        def check_cipher(cipher)
+          siba_file.run_this("check_cipher") do
+            supported_ciphers = nil
+            begin
+              supported_ciphers = Encryption.get_cipher_names
+            rescue Exception
+              logger.error "'gpg' encryption utility is not found. Please install it."
+              raise
+            end
+
+            supported_ciphers_msg = "Please use one of the following: #{supported_ciphers.join(', ')}."
+            if cipher.nil?
+              cipher = Encryption::DEFAULT_CIPHER
+              raise Siba::CheckError, "Default cipher '#{cipher}' is not supported.
+#{supported_ciphers_msg}" unless supported_ciphers.include?(cipher)
+            else
+              cipher.upcase!
+            end
+            
+            raise Siba::CheckError, "'#{cipher}' cipher is not supported.
+#{supported_ciphers_msg}" unless supported_ciphers.include?(cipher)
+          end
+          cipher
+        end
+
+        def get_cipher_names          
+          output = siba_file.run_shell "gpg --version"
+          cipher_names = parse_cipher_names output
+          raise Siba::Error, "Failed to get the list of supported ciphers" if cipher_names.empty?
+          cipher_names
+        end
+
+        def parse_cipher_names(version)
+          scan = version.scan /Cipher:(.*?)\n\w+:/m
+          scan = version.scan /Cipher:(.*)/m if scan.size == 0
+          if scan.size == 0 || !scan[0].is_a?(Array) || scan[0].size == 0 || !scan[0][0].is_a?(String)
+            raise "Failed to parse gpg version information" 
+          end
+          scan = scan[0][0]
+          scan.gsub!(/ |\n/, "")
+          scan.split(",").each {|a| a.upcase!}
+        end
+      end
+
+      private
+
+      def check_password_strength
+        seconds_to_crack = Siba::PasswordStrength.seconds_to_crack(@passphrase)
+        if Siba::PasswordStrength.is_weak? seconds_to_crack
+          timespan_to_guess = Siba::PasswordStrength.seconds_to_timespan seconds_to_crack
+          guess_estimation_message = "It will take #{timespan_to_guess} to guess it."
+          logger.warn "Your encryption password is weak. #{guess_estimation_message}"
+        end
+      end
+    end
+  end
+end

data/lib/siba/plugins/encryption/gpg/init.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+
+require 'siba/helpers/password_strength'
+require 'siba/plugins/encryption/gpg/encryption'
+
+module Siba::Encryption
+  module Gpg
+    class Init
+      include Siba::LoggerPlug
+      include Siba::FilePlug
+      attr_accessor :encryption
+
+      def initialize(options)
+        passphrase = Siba::SibaCheck.options_string(options, "passphrase")
+        cipher = Siba::SibaCheck.options_string(options, "cipher", true)
+        @encryption = Siba::Encryption::Gpg::Encryption.new passphrase, cipher
+      end     
+
+      # Encrypt backup archive file (path_to_archive) and put it to dest_dir.
+      # Return the name of encrypted file. It must begin with archive name
+      # and its ending must always be the same.
+      def backup(path_to_archive, dest_dir)
+        logger.info "Encrypting backup with 'gpg', cipher: '#{encryption.cipher}'"
+        path_to_encrypted_file = encryption.encrypt path_to_archive
+
+        # move encrypted file to dest_dir
+        file_name = File.basename path_to_encrypted_file
+        dest_file_path = File.join dest_dir, file_name
+        siba_file.file_utils_mv path_to_encrypted_file, dest_file_path
+        file_name
+      end
+
+      # Decrypt backup file (path_to_backup) to_dir.
+      # Return the name of decrypted file.
+      def restore(path_to_backup, to_dir)
+        logger.info "Decrypting backup with 'gpg', cipher: '#{encryption.cipher}'"
+        decrypted_file_name = File.basename path_to_backup
+        decrypted_file_name.gsub! /\.gpg$/, ""
+        path_to_decrypted_file = File.join to_dir, decrypted_file_name
+        encryption.decrypt path_to_backup, path_to_decrypted_file
+        decrypted_file_name
+      end
+    end
+  end
+end

data/lib/siba/plugins/encryption/gpg/options.yml

@@ -0,0 +1,2 @@
+passphrase: "<%= Siba::SecurityHelper.generate_password_for_yaml %>"
+cipher: AES256 # or BLOWFISH, TWOFISH, 3DES...

data/lib/siba/plugins/installed_plugins.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+module Siba
+  class InstalledPlugins
+    GEM_PREFIX = "siba-"
+
+    class << self
+      include Siba::FilePlug
+
+      def installed?(category, type)
+        types = all_installed[category]
+        return false if types.nil? 
+        types.include? type
+      end
+      
+      def all_installed
+        @installed ||= find_installed
+      end
+
+      def plugin_path(category, type)
+        unless installed? category, type
+          raise Siba::Error, "Plugin #{plugin_category_and_type(category, type)} is not installed"
+        end
+        siba_file.run_this do
+          path = type_dir category, type
+          unless siba_file.file_directory? path
+            path = Siba::GemHelper.gem_path gem_name(category, type)
+            path = File.join path, "lib", gem_name(category, type) 
+          end
+          unless siba_file.file_directory? path
+            raise Siba::Error, "Failed to get path to plugin #{plugin_category_and_type(category, type)}"
+          end
+          path
+        end
+      end
+
+      def category_dir(category)
+        File.expand_path "../#{category}/",  __FILE__
+      end
+
+      def type_dir(category, type)
+        File.join category_dir(category), type
+      end
+
+      def gem_name(category, type)
+        "#{GEM_PREFIX}#{category}-#{type}" 
+      end
+
+      def plugin_category_and_type(category, type)
+        "#{category}#{type.nil? ? "" : '-' + type}"
+      end
+
+    private
+
+      def find_installed
+        installed = {}
+        Siba::GemHelper.all_local_gems.map{|a| a.name}.each do |item| 
+          Siba::Plugins::CATEGORIES.each do |category|
+            installed[category] ||= []
+            gem_prefix_full = /^#{GEM_PREFIX}#{category}-/
+            installed[category] << item.gsub(gem_prefix_full, '') if item =~ /#{gem_prefix_full}.*$/
+          end
+        end
+
+        Siba::Plugins::CATEGORIES.each do |category|
+          installed[category] += Dir.glob(File.join(category_dir(category),"*")).select { |entry|
+            File.directory? entry
+          }.select{|dir| File.file?(File.join(dir,"init.rb")) }
+            .map{|directory| File.basename(directory)}
+        end
+ 
+        installed
+      end
+
+    end
+  end
+end

data/lib/siba/plugins/plugin_loader.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+
+module Siba
+  class PluginLoader
+    include Siba::LoggerPlug
+    include Siba::FilePlug
+
+    InitClassName = "Init"
+
+    def self.loader
+      @loader ||= PluginLoader.new 
+    end
+
+    def load(category, type, options)
+      unless Siba::Plugins.valid_category? category
+        raise PluginLoadError, "Incorrect plugin category '#{category}'. Available plugin categories are: #{Siba::Plugins.categories_str}"
+      end
+
+      raise PluginLoadError, "Options data is incorrect for #{plugin_category_and_type} plugin." unless options.is_a? Hash
+
+      @category=category
+      @type=type
+      @options = options
+      logger.debug "Loading #{plugin_category_and_type} plugin"
+      
+      require_plugin
+      plugin_module = get_plugin_module
+      plugin_type_module = get_plugin_type_module plugin_module
+      init_class = get_plugin_init_class plugin_type_module
+      init_plugin(init_class)
+    end
+
+  private
+    attr_accessor :category, :type, :options
+
+    def require_plugin
+      path_to_init_file = File.join(plugin_dir, "init.rb")
+      if File.exists?(path_to_init_file)
+        require path_to_init_file
+      else
+        gem_name = Siba::InstalledPlugins.gem_name category, type
+        begin
+          Gem::Specification.find_by_name(gem_name) 
+        rescue Gem::LoadError
+          raise PluginLoadError, "Unknown type '#{type}' for '#{category}' plugin. #{available_types_msg}"
+        end
+        require gem_name
+      end
+    end
+
+    def get_plugin_module
+      plugin_module_name = "#{category.capitalize}"
+      Siba.const_get(plugin_module_name)
+    rescue Exception
+      raise PluginLoadError, "Failed to load #{plugin_category_and_type} plugin: module 'Siba::#{plugin_module_name}' is undefined." 
+    end
+
+    def get_plugin_type_module(plugin_module)
+      plugin_type_module_name = StringHelper.camelize type
+      plugin_module.const_get(plugin_type_module_name)
+    rescue
+      raise PluginLoadError, "Failed to load #{plugin_category_and_type} plugin: module 'Siba::#{category.capitalize}::#{plugin_type_module_name}' is undefined."
+    end
+
+    def get_plugin_init_class(plugin_type_module)
+      plugin_type_module.const_get InitClassName
+    rescue Exception => e
+      raise PluginLoadError, "#{InitClassName} class is undefined for #{plugin_category_and_type} plugin."
+    end
+
+    def init_plugin(plugin_init_class)
+      plugin_init_class.new options
+    rescue ArgumentError
+      logger.error "Failed to load #{plugin_category_and_type} plugin: 'initialize' method is not defined or has wrong agruments."
+      raise
+    end
+
+    def plugin_category_and_type
+      Siba::InstalledPlugins.plugin_category_and_type category, type
+    end
+
+    def plugins_root_dir
+      Siba::InstalledPlugins.category_dir category
+    end
+
+    def plugin_dir
+      Siba::InstalledPlugins.type_dir category, type
+    end
+
+    def available_types_msg
+      return "No #{category} plugins are installed." if find_all_installed.empty?
+      return "Available types are: #{find_all_installed.join(", ")}." if find_all_installed.size > 1
+      "Available type is '#{find_all_installed.join(", ")}'."
+    end
+
+    def find_all_installed
+      Siba::InstalledPlugins.all_installed[category]
+    end
+  end
+end