siba 0.4.3

data/lib/siba/siba_check.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+module Siba
+  class SibaCheck
+    class << self
+      def options_bool(options, key_name, is_optional = false, default_value=false)
+        check_options options, key_name, [TrueClass, FalseClass], is_optional, default_value
+      end
+
+      def options_hash(options, key_name, is_optional = false, default_value=nil)
+        check_options options, key_name, Hash, is_optional, default_value
+      end
+
+      def options_string(options, key_name, is_optional = false, default_value=nil)
+        check_options(options, key_name, String, is_optional, default_value)
+      end
+
+      def options_string_array(options, key_name, is_optional = false, default_value=nil)
+        value = options[key_name]
+        if value.nil?
+          return default_value if is_optional
+          raise Siba::CheckError, "'#{key_name}' option is not defined"
+        end
+
+        begin
+          if value.is_a? Array
+            value.each_index do |i|
+              value[i] = try_to_s value[i], key_name
+            end
+          else
+            value = [ try_to_s(value, key_name) ]
+          end
+        rescue Exception
+          raise Siba::CheckError, "'#{key_name}' option should be string or an array of strings"
+        end
+        value
+      end
+
+      def hash(obj, name, is_optional=false)
+        if obj.nil?
+          return nil if is_optional
+          raise Siba::CheckError, "'#{name}' option is not defined"
+        end
+        raise Siba::CheckError, "'#{name}' option should be of [Hash] type" unless obj.is_a? Hash
+        obj
+      end
+      
+      # Tries to conver value to string
+      def try_to_s(value, key_name)
+        raise Siba::CheckError, "'#{key_name}' option should be string" if [Array, Hash].any?{|a| value.is_a?(a)}
+        value = value.to_s.strip
+        raise Siba::CheckError, "'#{key_name}' option should not be empty" if value.empty?
+        value
+      end
+
+    private
+
+      def check_options(options, key_name, item_type, is_optional = false, default_value = nil)
+        value = options[key_name]
+        if value.nil?
+          raise Siba::CheckError, "'#{key_name}' option is not defined" unless is_optional
+          return default_value
+        end
+
+        if item_type == String
+          value = try_to_s value, key_name
+        else
+          item_type = [item_type] unless item_type.is_a?(Array) 
+          raise Siba::CheckError, "'#{key_name}' option should be of #{item_type.to_s} type" if item_type.none? {|i| value.is_a? i } 
+        end
+        value
+      end
+    end
+  end
+end

data/lib/siba/siba_file.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+
+require 'fileutils'
+require 'tmpdir'
+require 'open3'
+
+module Siba
+  class SibaFile
+    def run_this(name="noname")
+      yield
+    end
+
+    DIR_REGEXP = /^dir_/
+    FILE_REGEXP = /^file_/
+    FILE_UTILS_REGEXP = /^file_utils_/
+
+    def self.get_file_class(meth)
+      case meth
+      when FILE_UTILS_REGEXP
+        return FileUtils, meth.to_s.gsub(FILE_UTILS_REGEXP, "")
+      when DIR_REGEXP
+        return Dir, meth.to_s.gsub(DIR_REGEXP, "")
+      when FILE_REGEXP
+        return File, meth.to_s.gsub(FILE_REGEXP, "")
+      end
+    end
+    
+    def method_missing(meth, *args, &block)
+      file_class, class_meth = SibaFile.get_file_class meth
+      if file_class
+        file_class.send(class_meth, *args, &block)  
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      if SibaFile.get_file_class meth
+        true
+      else
+        super
+      end
+    end
+
+    def file_expand_path(file_name, dir_string=nil)
+      file_utils_cd Siba.current_dir unless Siba.current_dir.nil?
+      File.expand_path file_name, dir_string
+    end
+
+    # Runs shell command and raises error if it fails
+    # returns output (both stdout and stderr)
+    def run_shell(command, fail_message=nil)
+      strout, status = Open3.capture2e command
+      raise strout if status.to_i != 0
+      return strout
+    rescue Exception => ex
+      fail_message ||= "Failed to run the command: #{command}"
+      raise Siba::Error, "#{fail_message}
+#{ex.message}" 
+    end
+
+    # Runs the shell command. 
+    # Works the same way as Kernel.system method but without showing the output.
+    # Returns true if it was successfull.
+    def shell_ok?(command)
+      # Using Open3 instead of `` or system("cmd") in order to hide stderr output
+      sout, status = Open3.capture2e command
+      return status.to_i == 0
+    rescue
+      return false
+    end
+  end
+  
+  # Used to inject "siba_file" to classes that include this module
+  module FilePlug
+    def siba_file
+      FilePlug.siba_file
+    end
+
+    def self.siba_file
+      @siba_file ||= SibaFile.new 
+    end
+
+    # It is used in test to insert mock SibaFile object
+    def self.siba_file=(val)
+      @siba_file = val
+    end
+  end
+end

data/lib/siba/siba_kernel.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Siba
+  class SibaKernel
+    undef_method :puts
+    def method_missing(meth, *args, &block)
+      if Kernel.respond_to? meth
+        Kernel.send meth, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      if Kernel.respond_to? meth
+        true
+      else
+        super
+      end
+    end
+  end
+
+  module KernelPlug
+    def siba_kernel
+      KernelPlug.siba_kernel
+    end
+
+    def self.siba_kernel
+      @siba_kernel ||= Siba::SibaKernel.new
+    end
+
+    # It is used in test to insert mock SibaKernel object
+    def self.siba_kernel=(val)
+      @siba_kernel = val
+    end
+  end
+end

data/lib/siba/siba_logger.rb

@@ -0,0 +1,172 @@
+# encoding: UTF-8
+require 'logger'
+
+module Siba
+  class SibaLogger
+    LogLevels = %w(debug info warn error fatal unknown)
+
+    class << self
+      attr_accessor :quiet, :verbose, :no_log, :messages
+
+      def log_level?(level)
+        SibaLogger::LogLevels.include? level
+      end
+
+      def check_log_level(level)
+        raise "Unsupported log level '#{level}'" unless SibaLogger::log_level? level
+      end
+
+      def level_to_i(level)
+        check_log_level level
+        SibaLogger::LogLevels.index level
+      end
+
+      def count(severity=nil, exact_level=true)
+        return 0 if SibaLogger.messages.nil?
+        return SibaLogger.messages.size if severity.nil?
+        severity_i = SibaLogger.level_to_i severity
+        SibaLogger.messages.count do |i| 
+          if exact_level 
+            i.level == severity_i 
+          else 
+            i.level >= severity_i
+          end
+        end
+      end
+    end
+
+    attr_accessor :show_finish_message
+
+    def initialize(name, path_to_log_file, show_start_message = true)
+      @show_finish_message = true
+      @name = name
+      SibaLogger.messages = []
+      @loggers = []
+
+      @strlog = StringIO.new
+      @loggers << Logger.new(@strlog)
+
+      unless SibaLogger.quiet
+        @stdout_log = Logger.new(STDOUT) 
+        @loggers << stdout_log
+      end
+
+      unless path_to_log_file.nil? || SibaLogger.no_log
+        @file = File.open(path_to_log_file, "a:utf-8")
+        @file_log = Logger.new(file) 
+        @loggers << file_log
+      end
+
+      @loggers.each do |logger|
+        logger.formatter = method(:formatter)
+      end
+
+      file_log.info "
+||----------NEW LOG----------||
+|| #{Time.now} ||
+||---------------------------||
+" unless file_log.nil?
+
+      info "#{name} started" if show_start_message
+    end
+
+    def to_s
+      strlog.string
+    end
+
+    def close
+      if show_finish_message
+        if SibaLogger.count('fatal') > 0
+          info "#{name} failed"
+        elsif SibaLogger.count('warn', false) == 0
+          info "#{name} finished successfully"
+        else
+          info "#{name} completed with some issues"
+        end
+      end
+
+      unless file.nil?
+        file.close
+      end
+
+      unless file_log.nil?
+        file_log.close
+      end
+      @loggers = []
+      @strlog = nil
+      @file_log = nil
+      @file = nil
+      @stdout_log = nil
+    end
+
+    def warn(*args, &block)
+      log('warn', *args, &block)
+    end
+
+    def log_exception(exception, log_only_backtrace=false)
+      log('debug',exception.message) unless log_only_backtrace
+      unless exception.backtrace.nil?
+        log('debug',"\n--- stack trace ---\n#{exception.backtrace.join("\n")}\n--- stack trace ---") 
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if SibaLogger::log_level? meth.to_s
+        log(meth.to_s, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth)
+      if SibaLogger::log_level? meth.to_s
+        true
+      else
+        super
+      end
+    end
+
+  private
+    attr_accessor :loggers, :name, :strlog, :file_log, :stdout_log, :file
+
+    def log(level, *args, &block)
+      raise Siba::Error, "Log is closed" if loggers.empty?
+      level_i = SibaLogger::level_to_i level
+      unless block.nil?
+        msg = block.call.to_s
+      else
+        assert "Wrong number of arguments" if args.size != 1
+        msg = args[0].to_s
+      end
+
+      log_message = LogMessage.new
+      log_message.level = level_i
+      log_message.time = Time.now
+      log_message.msg = msg
+      SibaLogger.messages << log_message
+
+      loggers.each do |l|
+        l.send(level, msg) unless l == stdout_log
+      end
+
+      unless stdout_log.nil?
+        stdout_log.send(level, EncodingHelper.encode_to_external(msg)) unless level == 'debug' && !SibaLogger.verbose
+      end
+    end
+
+    def formatter(severity, datetime, progname, msg)
+      if ["INFO", "DEBUG"].include? severity
+        severity = ""
+      else
+        severity = "WARNING" if severity == "WARN"
+        severity += " - "
+      end
+
+      "#{severity}#{msg}\n"
+    end
+  end
+
+  class LogMessage
+    attr_accessor :level, :time, :msg
+  end
+end

data/lib/siba/tasks/siba_task.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+
+module Siba
+  class SibaTask
+    include Siba::LoggerPlug
+
+    attr_accessor :category, :type, :options, :plugin
+
+    def initialize(options, category)
+      @category = category
+      load Siba::SibaCheck.options_hash(options, category)
+    rescue
+      logger.error "Failed to load #{category} plugin"
+      raise
+    end
+
+    def backup(*args)
+      logger.debug "Running #{category}/#{type}"
+      @plugin.backup *args
+    rescue Exception
+      logger.error "Failed to backup #{category}/#{type}"
+      raise
+    end
+
+    def restore(*args)
+      logger.debug "Restoring #{category}/#{type}"
+      @plugin.restore *args
+    rescue Exception
+      logger.error "Failed to restore #{category}/#{type}"
+      raise
+    end
+
+  private
+
+    def load(options)
+      @options = options
+      @type = Siba::SibaCheck.options_string(@options, "type")
+      @type.downcase! 
+      @plugin = Siba::PluginLoader.loader.load(category, type, options)
+    end
+  end
+end

data/lib/siba/tasks/siba_tasks.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+require 'siba/tasks/siba_task'
+
+module Siba
+  class SibaTasks
+    include Siba::FilePlug
+    attr_accessor :tasks
+
+    def initialize(options, path_to_options_yml, skip_source_task)
+      @path_to_options_yml = path_to_options_yml
+      raise 'Options are not loaded' if options.nil?
+
+      @tasks = {}
+      Siba::Plugins::CATEGORIES.each do |category|
+        next if category == "source" && skip_source_task
+        @tasks[category] = SibaTask.new options, category
+      end
+    end
+
+    def backup
+      siba_file.run_this "backup" do
+        @tasks["source"].backup source_dir
+        raise Siba::Error, "There are no files to backup" if Siba::FileHelper.dir_empty? source_dir
+        OptionsBackup.save_options_backup path_to_options_yml, source_dir
+
+        archive_file_name = @tasks["archive"].backup source_dir, archive_dir, SibaTasks.backup_name
+        unless archive_file_name =~ /^#{SibaTasks.backup_name}/
+          raise Siba::Error, "Archive file name must begin with: #{SibaTasks.backup_name}"
+        end
+        path_to_archive = File.join archive_dir, archive_file_name
+        unless siba_file.file_file? path_to_archive
+          raise Siba::Error, "Failed to create archive file: #{path_to_archive}"
+        end
+
+        name_of_encrypted_file = @tasks["encryption"].backup path_to_archive, encryption_dir
+        unless name_of_encrypted_file =~ /^#{archive_file_name}/
+          raise Siba::Error, "File name of encrypted file must begin with: #{archive_file_name}"
+        end
+        path_to_backup = File.join encryption_dir, name_of_encrypted_file
+        unless siba_file.file_file? path_to_backup
+          raise Siba::Error, "Failed to encrypt backup: #{path_to_backup}" 
+        end
+
+        @tasks["destination"].backup path_to_backup
+      end
+    end
+
+    def restore(backup_file_name)
+      siba_file.run_this do
+        @tasks["destination"].restore backup_file_name, destination_dir
+        path_to_backup = File.join destination_dir, backup_file_name
+        unless siba_file.file_file? path_to_backup
+          raise Siba::Error, "Failed to get backup from destination: #{backup_file_name}"
+        end
+        
+        archive_file_name = @tasks["encryption"].restore path_to_backup, encryption_dir
+        path_to_archive = File.join encryption_dir, archive_file_name
+        unless siba_file.file_file? path_to_archive
+          raise Siba::Error, "Failed to get archive file: #{path_to_archive}"
+        end
+
+        @tasks["archive"].restore path_to_archive, source_dir
+        if Siba::FileHelper.dir_empty? source_dir
+          raise Siba::Error, "Failed to extract archive: #{path_to_archive}"
+        end
+      
+        @tasks["source"] = OptionsBackup.load_source_from_backup source_dir
+        @tasks["source"].restore source_dir
+      end
+    end
+
+    def get_backups_list
+      @tasks["destination"].plugin.get_backups_list Siba.backup_name
+    end
+
+    def self.backup_name(now=nil)
+      if Siba::StringHelper.nil_or_empty Siba.backup_name
+        raise Siba::Error, "Backup task name is not specified" 
+      end
+      "#{Siba.backup_name}-#{SibaTasks.backup_name_suffix(now)}"
+    end
+
+
+  private
+    attr_accessor :path_to_options_yml
+
+    def source_dir
+      @source_dir ||= TestFiles::mkdir_in_tmp_dir("src").freeze
+    end
+
+    def archive_dir
+      @archive_dir ||= TestFiles::mkdir_in_tmp_dir("arc").freeze
+    end
+
+    def encryption_dir
+      @encryption_dir ||= TestFiles::mkdir_in_tmp_dir("enc").freeze
+    end
+    
+    def destination_dir
+      @destination_dir ||= TestFiles::mkdir_in_tmp_dir("dest").freeze
+    end
+
+    def self.backup_name_suffix(now=nil)
+      now ||= Time.now
+
+      # Monthly backup on the 1st day of each month
+      # "month-01" through "month-12"
+      return "month-#{"%02d" % now.month}" if now.day == 1 
+
+      # Weekly backup on Sunday
+      # "week-1-sun" through "week-5-sun"
+      return "week-#{(now.day-1) / 7 + 1}-sun" if now.wday == 0
+
+      # Daily backup
+      # "day-2-mon" through "day-7-sat"
+      "day-#{now.wday+1}-#{now.strftime("%a").downcase}"  
+    end
+  end
+end