ubsafe 0.5

data/README

@@ -0,0 +1,9 @@
+README
+========================================================================
+ubsafe - simplify and automate backup tasks
+
+Installation
+------------
+
+(Soon) gem install ubsafe
+

data/bin/ubsafe

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'ubsafe'

data/bin/ubsafe_cmd_with_password.expect

@@ -0,0 +1,11 @@
+#!/usr/bin/expect
+
+set cmd [lindex $argv 0]
+set params [lindex $argv 2]
+set password [lindex $argv 1]
+spawn $cmd $params
+expect "Password:"
+send "$password\r"
+expect eof
+
+

data/bin/ubsafe_file_exists

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+if File.exists?(ARGV[0])
+  puts "0"
+  exit 0
+else
+  puts "1"
+  exit 1
+end

data/bin/ubsafe_file_mtime

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+file_name = ARGV[0]
+
+if File.exists?(file_name)
+  original_file_mtime_utc = File.mtime(file_name).getutc
+  puts original_file_mtime_utc.strftime('%Y-%m-%d %H:%M:%S')
+else
+  puts ''
+end

data/bin/ubsafe_scp_cmd.expect

@@ -0,0 +1,12 @@
+#!/usr/bin/expect
+
+set user_and_host [lindex $argv 0]
+set password [lindex $argv 1]
+set source_file [lindex $argv 2]
+set destination [lindex $argv 3]
+spawn scp $source_file $user_and_host:$destination
+expect "Password:"
+send "$password\r"
+expect eof
+
+

data/bin/ubsafe_ssh_cmd.expect

@@ -0,0 +1,11 @@
+#!/usr/bin/expect
+
+set user_and_host [lindex $argv 0]
+set password [lindex $argv 1]
+set ssh_command [lindex $argv 2]
+spawn ssh  $user_and_host "$ssh_command"
+expect "Password:"
+send "$password\r"
+expect eof
+
+

data/bin/ubsafer

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+# If we're in development mode - i.e running in the root of the gem source
+script_dir = File.dirname(File.expand_path(__FILE__))
+current_dir = Dir.getwd
+if script_dir.index(current_dir) 
+  unless defined?(::UBSAFE_ROOT)
+    puts "ubsafe: WARNING operating in development mode"
+    UBSAFE_ROOT = current_dir
+    require File.expand_path(File.join(current_dir, 'lib', 'ubsafe','extensions', 'ubsafe_extensions'))
+    require File.join_from_here('ubsafe','ubsafe_config')
+    require File.join_from_here('ubsafe','ubsafe_commands','ubsafe_commands')
+  end
+else
+  gem 'ubsafe','0.5'
+  require 'ubsafe'
+end
+
+UBSafe::Commands::Backup.instance(ARGV).backup
+

data/lib/ubsafe.rb

@@ -0,0 +1,21 @@
+module UBSafe
+  
+end
+
+require 'rubygems'
+gem 'fastthread','= 1.0.7'
+require 'fastthread'
+gem 'logging','= 0.9.4'
+require 'logging'
+
+unless defined?(::UBSAFE_ROOT)
+  
+  UBSAFE_ROOT = File.expand_path(File.join(File.dirname(__FILE__),'..')) 
+
+  require File.expand_path(File.join(File.dirname(__FILE__), 'ubsafe','extensions', 'ubsafe_extensions'))
+  require File.join_from_here('ubsafe','ubsafe_config')
+  require File.join_from_here('ubsafe','ubsafe_commands','ubsafe_commands')
+  
+end
+
+

data/lib/ubsafe/extensions/ubsafe_extensions.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'ubsafe_kernel_extensions'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'ubsafe_file_extensions'))
+require File.join_from_here('ubsafe_integer_extensions')
+require File.join_from_here('ubsafe_hash_extensions')
+require File.join_from_here('ubsafe_logging_extensions')

data/lib/ubsafe/extensions/ubsafe_file_extensions.rb

@@ -0,0 +1,34 @@
+class File
+  
+  alias_class_method :join
+  
+  class << self
+    
+    # With thanks to the Mack framework
+
+    ##
+    # Join a list of paths as strings and/or arrays of strings
+    #
+    # @param args [Array] (Nested) list of paths to join
+    # @return Joined list
+    # Join now works like it should! It calls .to_s on each of the args
+    # pass in. It handles nested Arrays, etc...
+    #
+    def join(*args)
+      fs = [args].flatten
+      _ubsafe_original_join(fs.collect{|c| c.to_s})
+    end
+    
+    ##
+    # Perform a join relative to the current file. Fully qualify the path name.
+    #
+    # @param   args [Array] (Nested) list of paths to join
+    #
+    def join_from_here(*args)
+      caller.first.match(/(.+):.+/)
+      File.expand_path(File.expand_path(File.join(File.dirname($1), *args)))
+    end
+    
+  end
+  
+end

data/lib/ubsafe/extensions/ubsafe_hash_extensions.rb

@@ -0,0 +1,15 @@
+class Hash
+  
+  def dup_contents_1_level
+    dup = Hash.new
+    self.each do |key,val|
+      begin
+        dup[key] = val.dup
+      rescue Exception => ex
+        dup[key] = val
+      end
+    end
+    return dup
+  end
+  
+end

data/lib/ubsafe/extensions/ubsafe_integer_extensions.rb

@@ -0,0 +1,45 @@
+class Integer
+  
+    def seconds
+      return self.to_i
+    end
+    
+    alias_method :second, :seconds
+    
+    def mins
+      return self.to_i * 60
+    end
+    
+    alias_method :min, :mins
+    
+    def hours
+      return self.mins * 60
+    end
+    
+    alias_method :hour, :hours
+    
+    def days
+      return self.hours * 24
+    end
+    
+    alias_method :day, :days
+    
+    def weeks
+      return self.days * 7
+    end
+
+    alias_method :week, :weeks
+    
+    def months
+      return self.days * 30
+    end
+    
+    alias_method :month, :months
+    
+    def years
+      return self.days * 365
+    end
+    
+    alias_method :year, :years
+    
+end

data/lib/ubsafe/extensions/ubsafe_kernel_extensions.rb

@@ -0,0 +1,35 @@
+module Kernel
+
+  # With thanks to the Mack framework
+  
+  ##
+  # Aliases a class method to a new name. It will only do the aliasing once, to prevent
+  # issues with reloading a class and causing a StackLevel too deep error.
+  # The method takes two arguments, the first is the original name of the method, the second,
+  # optional, parameter is the new name of the method. If you don't specify a new method name
+  # it will be generated with _original_<original_name>.
+  # 
+  # Example:
+  #   class President
+  #     alias_class_method :good
+  #     alias_class_method :bad, :old_bad
+  #     def self.good
+  #       'Bill ' + _original_good
+  #     end
+  #     def self.bad
+  #       "Either #{old_bad}"
+  #     end
+  #   end
+  #
+  # @param orig_name [String] The original class method to alias
+  # @param new_name [String] The new alias. Defaults to '_ubsafe_original_[name]'
+  #
+  def alias_class_method(orig_name, new_name = "_ubsafe_original_#{orig_name}")
+    eval(%{
+      class << self
+        alias_method :#{new_name}, :#{orig_name} unless method_defined?("#{new_name}")
+      end
+    })
+  end
+  
+end

data/lib/ubsafe/extensions/ubsafe_logging_extensions.rb

@@ -0,0 +1,136 @@
+module Logging
+  module Layouts
+    # Layout to be shared among all StandardizedLogger logging classes
+    class UBSafeLoggerLayout < ::Logging::Layout
+
+      attr_reader :app_name
+      
+      def initialize(configuration)
+        @configuration = configuration
+        @app_name = configuration[:log_identifier]
+      end
+      
+      # Get the (cached) hostname for this machine
+      def hostname
+        unless defined?(@@hostname)
+          @@hostname = `hostname`.chomp.strip.downcase
+        end
+        return @@hostname
+      end
+      
+      # call-seq:
+      #    format( event )
+      #
+      # Returns a string representation of the given loggging _event_. See the
+      #
+      def format( event )
+        msg = format_obj(event.data)
+        severity_text = ::Logging::LNAMES[event.level]
+        preamble = "#{Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")}\tUTC\t[#{severity_text}]\t[#{hostname}]\t[#{app_name}]\t[#{$$}]\t"
+        full_message =  preamble + (msg || '[nil]')
+        full_message.gsub!(/\n/,' ')
+        full_message += "\n" unless full_message =~ /\n$/
+        return full_message
+      end
+
+    end
+    
+  end
+end
+
+# Patch below changes all log-related times to UTC
+
+require 'lockfile'
+
+module Logging::Appenders
+  class RollingFile < ::Logging::Appenders::IO
+
+
+    def initialize( name, opts = {} )
+      # raise an error if a filename was not given
+      @fn = opts.getopt(:filename, name)
+      raise ArgumentError, 'no filename was given' if @fn.nil?
+      ::Logging::Appenders::File.assert_valid_logfile(@fn)
+
+      # grab the information we need to properly roll files
+      ext = ::File.extname(@fn)
+      bn = ::File.join(::File.dirname(@fn), ::File.basename(@fn, ext))
+      @rgxp = %r/\.(\d+)#{Regexp.escape(ext)}\z/
+      @glob = "#{bn}.*#{ext}"
+      @logname_fmt = "#{bn}.%d#{ext}"
+
+      # grab our options
+      @keep = opts.getopt(:keep, :as => Integer)
+      @size = opts.getopt(:size, :as => Integer)
+
+      @lockfile = if opts.getopt(:safe, false) and !::Logging::WIN32
+        ::Lockfile.new(
+            @fn + '.lck',
+            :retries => 1,
+            :timeout => 2
+        )
+      end
+
+      code = 'def sufficiently_aged?() false end'
+      @age_fn = @fn + '.age'
+
+      case @age = opts.getopt(:age)
+      when 'daily'
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
+        code = <<-CODE
+        def sufficiently_aged?
+          now = Time.now.utc
+          start = ::File.mtime(@age_fn).utc
+          if (now.day != start.day) or (now - start) > 86400
+            return true
+          end
+          false
+        end
+        CODE
+      when 'weekly'
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
+        code = <<-CODE
+        def sufficiently_aged?
+          if (Time.now.utc - ::File.mtime(@age_fn).utc) > 604800
+            return true
+          end
+          false
+        end
+        CODE
+      when 'monthly'
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
+        code = <<-CODE
+        def sufficiently_aged?
+          now = Time.now.utc
+          start = ::File.mtime(@age_fn).utc
+          if (now.month != start.month) or (now - start) > 2678400
+            return true
+          end
+          false
+        end
+        CODE
+      when Integer, String
+        @age = Integer(@age)
+        FileUtils.touch(@age_fn) unless test(?f, @age_fn)
+        code = <<-CODE
+        def sufficiently_aged?
+          if (Time.now.utc - ::File.mtime(@age_fn).utc) > @age
+            return true
+          end
+          false
+        end
+        CODE
+      end
+      meta = class << self; self end
+      meta.class_eval code, __FILE__, __LINE__
+
+      # if the truncate flag was set to true, then roll 
+      roll_now = opts.getopt(:truncate, false)
+      roll_files if roll_now
+
+      super(name, open_logfile, opts)
+    end
+
+  end
+end
+

data/lib/ubsafe/ubsafe_commands/ubsafe_command_backup.rb

@@ -0,0 +1,647 @@
+require 'parsedate'
+require 'net/smtp'
+require 'tmpdir'
+
+module UBSafe
+
+  module Commands
+    
+    class Backup
+      
+      class << self
+        
+        ##
+        # Get backup-specific backup instance
+        #
+        # @param [Array] args Command-line arguments
+        #
+        def instance(args)
+          @config = UBSafe::Config.config
+          @config.load(args)
+          @backup_name = @config.options[:backup_name]
+          @backup_options = @config.full_options(@backup_name)
+          backup_class = @backup_options[:backup_class]
+          backup_instance = nil
+          if backup_class == :default
+            backup_instance = UBSafe::Commands::Backup.new(args)
+          else
+            eval("backup_instance = #{backup_class.to_s}.new(args)")
+          end
+          return backup_instance
+        end
+        
+      end
+      
+      ##
+      # Create a new backup instance
+      #
+      # @param [Array] args Command-line arguments
+      #
+      def initialize(args)
+        @config = UBSafe::Config.config
+        @config.load(args)
+        @backup_name = @config.options[:backup_name]
+        @backup_options = @config.full_options(@backup_name)
+        @log = @config.log
+      end
+      
+      ##
+      # Perform backup
+      #
+      # @return [Integer] Exit code 0 success, 1 otherwise
+      #
+      def backup
+        # Create backup file in source tree
+        # Rotate destination files
+        # Copy to destination
+        # Remove from source tree
+        backup_steps = [
+          :before_rotate_destination_files, :rotate_destination_files, :after_rotate_destination_files,
+          :before_source_backup,:create_source_backup,:after_source_backup,
+          :before_copy_backup, :copy_backup, :after_copy_backup,
+          :before_clean_source, :clean_source, :after_clean_source
+          ]
+        backup_steps.each do |backup_step|
+          status = self.send(backup_step)
+          if status == :failure
+            @log.error("Backup #{@backup_name} backup step #{backup_step.to_s} failed.")
+            email_notify(:failure,backup_step)
+            return 1
+          end
+        end
+        @log.info("Backup  #{@backup_name} succeeded")
+        email_notify(:success,nil)
+        return 0
+      end
+      
+      ##
+      # Hook to allow customization before creating source backup
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def before_source_backup
+        return :success
+      end
+
+      ##
+      # Hook to allow customization after creating source backup
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def after_source_backup
+        return :success
+      end
+      
+      ##
+      # Create source backup
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def create_source_backup(backup_options = nil,backup_name = nil)
+
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        
+        # Don't bother to create the backup if it already exists on the destination - i.e. hasn't been rolled
+        return :success if remote_file_exists?
+        
+        # Fully qualify directories
+        source_tree = File.expand_path(backup_options[:source_tree])
+        tmp_dir = File.expand_path(backup_options[:temporary_directory])
+          
+        if backup_options[:backup_style] == :tar_gz
+          status = nil
+          # Run command somewhere sensible
+          FileUtils.mkdir_p(tmp_dir)
+          Dir.chdir(tmp_dir) do |dir|
+            backup_cmd_tempate = "tar cfz %s -C %s ."
+            full_cmd = sprintf(backup_cmd_tempate,get_backup_file_name,source_tree)
+            @log.debug("create_source_backup #{full_cmd}")
+            cmd_result = `#{full_cmd}`
+            cmd_status = $?
+            status = cmd_status == 0 ? :success : :failure
+            if status == :success
+              @log.info("Backup '#{backup_name}' succeeded")
+            else
+              @log.error("Backup '#{backup_name}' failed")
+            end
+          end
+          return status
+        end
+        @log.error("Backup '#{backup_name}' - backup type specified is not supported")
+        return :failure
+      end
+      
+      ##
+      # Hook to allow customization before rotating destination files
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def before_rotate_destination_files
+        return :success
+      end
+
+      ##
+      # Hook to allow customization after rotating destination files
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def after_rotate_destination_files
+        return :success
+      end
+      
+      ##
+      # Rotate destination files. Check all the conditions
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def rotate_destination_files(backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        begin
+          # Make sure remote directory exists
+          remote_directory = File.join(backup_options[:base_backup_directory],backup_name)
+          remote_cmd = "mkdir -p #{remote_directory}"
+          cmd_status, cmd_output = ssh_cmd(remote_cmd)
+          return :failure unless cmd_status == :success
+          
+          backup_file_name = get_backup_file_name(backup_options)
+          remote_file_name = File.join(remote_directory,backup_file_name)
+          remote_file_mtime = get_remote_modified_timestamp(remote_file_name,backup_options,backup_name)
+          return_status = nil
+
+          backup_frequency = backup_options[:backup_frequency]
+          case backup_frequency
+            when Integer
+              # Explicit age
+              if remote_file_mtime
+                if (Time.now.utc - remote_file_mtime ) > backup_frequency
+                  return_status = rotate_destination_files_unconditionally(backup_options,backup_name)
+                end
+              end
+            when :daily
+              if remote_file_mtime
+                now = Time.now.utc
+                if (now.day != remote_file_mtime.day) or (now - remote_file_mtime) > 1.day
+                  return_status = rotate_destination_files_unconditionally(backup_options,backup_name)
+                end
+              end
+            when :weekly
+              if remote_file_mtime
+                if (Time.now.utc - remote_file_mtime) > 1.week
+                  return_status = rotate_destination_files_unconditionally(backup_options,backup_name)
+                end
+              end
+            when :monthly
+              if remote_file_mtime
+                now = Time.now.utc
+                if (now.month != remote_file_mtime.month) or (now - remote_file_mtime) > 1.month
+                  return_status = rotate_destination_files_unconditionally(backup_options,backup_name)
+                end
+              end
+          end
+        rescue Exception => ex
+          @log.error("Error detected while determining whether to rotate files")
+          @log.error(ex.to_s)
+          @log.error(ex.backtrace.join("\n"))
+          return_status = :failure
+        end
+        
+        return return_status
+        
+      end
+      
+      ##
+      # Rotate destination files unconditionally. Assume someone else has checked whether this is needed.
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def rotate_destination_files_unconditionally(backup_options = nil,backup_name = nil)
+        # Assume that all checks have been performed before calling this method. 
+        # This method will rotate files unconditionally
+
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        
+        return :failure unless backup_options[:backup_file_name_template] =~ /\%n/
+        
+        remote_directory_name = File.join(backup_options[:base_backup_directory],backup_name)
+        remote_cmd = "mkdir -p #{remote_directory_name}"
+        cmd_status, cmd_output = ssh_cmd(remote_cmd)
+        return :failure unless cmd_status == :success
+        remote_cmd = "ls -1t #{remote_directory_name}"
+        cmd_status, cmd_output = ssh_cmd(remote_cmd)
+        return :failure unless cmd_status == :success
+        remote_backup_files = cmd_output.reject {|line| line =~ /^\.$/ or line =~ /^\.\.$/ }
+        # Make sure we're initialized
+        backup_options[:all_possible_file_names] = all_backup_names(backup_options)
+        backups_to_retain = backup_options[:backups_to_retain]
+        # If no entries don't rotate
+        # If entries > 0 and entries < max, move all files down one position
+        # If entries >= max, remove last entry, then move all files down one position
+        unless remote_backup_files.empty?
+          # if entries >= max, 
+          if remote_backup_files.size >= backups_to_retain
+            # .. remove last entry
+            last_entry = remote_backup_files.pop
+            remote_cmd = "rm -f #{File.join(remote_directory_name,last_entry)}"
+            cmd_status, cmd_output = ssh_cmd(remote_cmd)
+            return :failure unless cmd_status == :success
+          end
+          # Need to reverse order
+          remote_backup_files.size.downto(1) do |current_generation|
+            #puts "rotate_destination_files_unconditionally current_generation #{current_generation}"
+            file_name_current_generation = remote_backup_files[current_generation - 1]
+            #puts "rotate_destination_files_unconditionally file_name_current_generation #{file_name_current_generation}"
+            file_name_previous_generation = backup_options[:all_possible_file_names][current_generation]
+            #puts "rotate_destination_files_unconditionally file_name_previous_generation #{file_name_previous_generation}"
+            remote_cmd = "mv #{File.join(remote_directory_name,file_name_current_generation)} #{File.join(remote_directory_name,file_name_previous_generation)}"
+            cmd_status, cmd_output = ssh_cmd(remote_cmd)
+            @log.debug("Rotated #{File.join(remote_directory_name,file_name_current_generation)} to  #{File.join(remote_directory_name,file_name_previous_generation)} Status #{cmd_status}")
+            return :failure unless cmd_status == :success
+          end
+          
+        end
+          
+        return :success
+
+      end
+
+      ##
+      # Hook to allow customization before copying backup
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def before_copy_backup
+        return :success
+      end
+
+      ##
+      # Hook to allow customization after copying backup
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def after_copy_backup
+        return :success
+      end
+
+      ##
+      # Create and copy backup
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def create_and_copy_backup(backup_options = nil,backup_name = nil)
+
+      end
+      ##
+      # Copy backup 
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def copy_backup(backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        # Fully qualify directories
+        tmp_dir = File.expand_path(backup_options[:temporary_directory])
+        backup_file_name = get_backup_file_name(backup_options)
+        qualified_backup_file_name = File.join(tmp_dir,backup_file_name)
+        remote_directory_name = File.join(backup_options[:base_backup_directory],backup_name)
+        qualified_remote_file_name = File.join(remote_directory_name,backup_file_name)
+        unless remote_file_exists?(qualified_remote_file_name)
+          # Only copy file if it's not there
+          cmd_status, cmd_output = scp_cmd(qualified_backup_file_name,remote_directory_name,backup_options,backup_name)
+          return :failure unless cmd_status == :success
+        end
+        return :success
+      end
+
+      ##
+      # Hook to allow customization before cleaning source
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def before_clean_source
+        return :success
+      end
+
+      ##
+      # Hook to allow customization after cleaning source
+      #
+      # @return [Symbol] :success or :failure
+      #
+      def after_clean_source
+        return :success
+      end
+
+      ##
+      # Clean Source - remove (temporary) backup files from source
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Symbol] :success or :failure
+      #
+      def clean_source(backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        # Fully qualify directories
+        tmp_dir = File.expand_path(backup_options[:temporary_directory])
+        backup_file_name = File.join(tmp_dir,get_backup_file_name(backup_options))
+        cmd_output = `rm -f #{backup_file_name}`
+        cmd_status = $?
+        return cmd_status == 0 ? :success : :failure
+      end
+
+      ##
+      # Notify via email
+      #
+      # @param [Symbol] status
+      # @param [Symbol] processing_step
+      # @return [Symbol] :success or :failure
+      #
+      def email_notify(status = :failure,processing_step = nil)
+        mail_config = @config.options[:backup_email]
+        return :success unless mail_config[:enabled]
+        backup_options = @backup_options
+        backup_name = @backup_name
+        hostname = `hostname`.chomp.strip
+        log_directory = File.expand_path(@config.options[:logging][:log_directory])
+        if status == :success
+          subject = "#{mail_config[:mail_subject_prefix]} backup '#{backup_name}' OK"
+          body = "Backup '#{backup_name}' succeeded"
+          body << "\n\nLogs are available at #{hostname}:#{log_directory}"
+        else
+          processing_step = processing_step ? processing_step.to_s : 'unknown'
+          subject = "#{mail_config[:mail_subject_prefix]} backup '#{backup_name}' failed at backup stage '#{processing_step}'"
+          body = "backup '#{backup_name}' failed at backup stage '#{processing_step}'"
+          body << "\n\nLogs are available at #{hostname}:#{log_directory}"
+        end
+        email_date = Time.now.utc.strftime('%a, %d %b %y %H:%M:%S')
+        recipients = mail_config[:mail_to]
+        recipients.each do |recipient|
+          
+              full_body = <<BODY
+Mime-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Content-Type: text/plain;
+	charset=US-ASCII;
+	format=flowed
+To: #{recipient}
+From: #{mail_config[:mail_from]}
+Subject: #{subject}
+Date: #{email_date}
+
+#{body}
+
+BODY
+         if mail_config[:mail_style] == :smtp
+            Net::SMTP.start(mail_config[:smtp_host]) do |session|
+              session.sendmail(full_body, mail_config[:mail_from] , recipient)
+            end
+          else
+            tmp_dir = Dir.tmpdir
+            mail_msg_file = File.join(tmp_dir,'mail.txt')
+            File.open(mail_msg_file,'w') do |file|
+              file.write full_body
+            end
+            cmd = "cat #{mail_msg_file} | sendmail #{recipient}"
+            #puts "email_notify cat_sendmail issuing command \"#{cmd}\""
+            cmd_output = `#{cmd}`
+            cmd_status = $?
+            File.delete(mail_msg_file)
+            @log.debug("email_notify: cat_sendmail status #{cmd_status} output #{cmd_output}")
+          end
+        end
+        return :success
+      end
+      
+      ##
+      # Get backup name - use the template defined in the configuration file
+      #
+      # @param [Hash] backup_options Backup options
+      # @return [String] Unqualified name of backup file
+      #
+      def get_backup_file_name(backup_options = nil)
+        backup_options ||= @backup_options
+        return get_backup_file_name_with_generation(backup_options,0)
+      end
+
+      ##
+      # Get ordered list of all possible backup names given the supplied configuration
+      #
+      # @param [Hash] backup_options Backup options
+      # @return [Array] Ordered list of backup names - newest first
+      #
+      def all_backup_names(backup_options = nil)
+        backup_options ||= @backup_options
+        all_possible_file_names = []
+        total_possible_file_names = backup_options[:backups_to_retain]
+        total_possible_file_names.times do |current_generation|
+          all_possible_file_names[current_generation] = get_backup_file_name_with_generation(backup_options,current_generation)
+        end
+        @backup_options[:all_possible_file_names] = all_possible_file_names
+        return all_possible_file_names
+      end
+      
+      ##
+      # Get backup name with the specified generation- use the template defined in the configuration file
+      #
+      # @param [Hash] backup_options Backup options
+      # @param [Integer] generation Generation number
+      # @return [String] Unqualified name of backup file
+      #
+      def get_backup_file_name_with_generation(backup_options = nil, generation = 1)
+        backup_options ||= @backup_options
+        template = backup_options[:backup_file_name_template]
+        file_name = backup_options[:backup_name]
+        # The new backup is always 1
+        file_number = generation
+        # Get default time zone
+        time_zone = (backup_options[:time_zone] || 'UTC').to_s.upcase
+        current_time = time_zone == 'UTC' ? Time.now.utc : Time.now
+        time_stamp = current_time.strftime(backup_options[:timestamp_format])
+        date_stamp = current_time.strftime(backup_options[:date_format])
+        # Translate the template to a sprintf format string
+        # %f => file name
+        # %n => backup_options[:number_format] for file number
+        # %t => backup_options[:timestamp_format]
+        # %d => backup_options[:date_format]
+        sprintf_template = template.gsub(/\%f/,'%s')
+        sprintf_template = sprintf_template.gsub(/\%n/,backup_options[:number_format])
+        sprintf_template = sprintf_template.gsub(/\%t/,'%s')
+        sprintf_template = sprintf_template.gsub(/\%d/,'%s')
+        # Now, figure out the order for the sprintf call
+        sprintf_fields = []
+        template_size = template.size
+        # We're matching a two-character placeholder string, so stop 2 chars from end
+        0.upto(template_size - 2) do |pos|
+          if template[pos,2] == '%f'
+            sprintf_fields << file_name
+          elsif template[pos,2] == '%n'
+            sprintf_fields << file_number
+          elsif template[pos,2] == '%t'
+            sprintf_fields << time_stamp
+          elsif template[pos,2] == '%d'
+            sprintf_fields << date_stamp
+          end
+        end
+        backup_file_name = sprintf(sprintf_template,*sprintf_fields)
+        return backup_file_name
+      end
+      
+      ##
+      # Get the modified time stamp for a remote file
+      #
+      # @param [String] file_name Fully qualified file name
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Time] File modification time or nil if no file found remotely
+      #
+      def get_remote_modified_timestamp(file_name,backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        remote_bin_dir = backup_options[:bin_dir] ? "#{backup_options[:bin_dir]}/" : ''
+        remote_cmd = "#{remote_bin_dir}ubsafe_file_mtime #{file_name}"
+        cmd_status, cmd_output = ssh_cmd(remote_cmd,backup_options,backup_name)
+        file_mtime = nil
+        if cmd_status == :success and (not cmd_output.empty?) and (cmd_output[0] != '')
+          #puts "get_remote_modified_timestamp file_name #{file_name} #{cmd_output[0]}"
+          file_mtime = Time.utc(*ParseDate.parsedate(cmd_output[0]))
+        end
+        return file_mtime  
+      end
+      
+      ##
+      # Issue an ssh command
+      #
+      # @param [String] cmd Command to send
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Array] [command status, command output]
+      #
+      def ssh_cmd(cmd,backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        ssh_user = backup_options[:user_name]
+        ssh_host = backup_options[:hostname]
+        ssh_password = backup_options[:password]
+        if ssh_password
+          # Need to use expect for the password if certs don't work
+          cmd_exe = File.expand_path(File.join(::UBSAFE_ROOT, 'bin','ubsafe_ssh_cmd.expect'))
+          full_cmd = "#{cmd_exe} #{ssh_user}@#{ssh_host} \"#{ssh_password}\" \"#{cmd}\""
+          masked_full_cmd = "#{cmd_exe} #{ssh_user}@#{ssh_host} [PASSWORD] \"#{cmd}\""
+        else
+          # Certs assumed if no password
+          full_cmd = "ssh #{ssh_user}@#{ssh_host} \"#{cmd}\""
+          masked_full_cmd = full_cmd
+        end
+        #puts "About to issue \"#{full_cmd}\""
+        cmd_output = `#{full_cmd}`
+        cmd_status = $?
+        @log.debug("Executed ssh status #{cmd_status} command \"#{masked_full_cmd}\"")
+        cmd_output_lines = cmd_output.split("\n").reject {|line| line =~ /spawn/i or line =~ /password/i }
+        cmd_output_cleaned = []
+        cmd_output_lines.each do |cmd_output_line|
+          cmd_output_cleaned << cmd_output_line.strip.chomp
+        end
+        cmd_status = cmd_status == 0 ? :success : :failure
+        return [cmd_status,cmd_output_cleaned]
+      end
+
+      ##
+      # Issue an scp command
+      #
+      # @param [String] source_file Fully qualified name of file to send
+      # @param [String] destination_dir Destination directory on remote host
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Array] [command status, command output]
+      #
+      def scp_cmd(source_file,destination_dir,backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        ssh_user = backup_options[:user_name]
+        ssh_host = backup_options[:hostname]
+        ssh_password = backup_options[:password]
+        if ssh_password
+          # Need to use expect for the password if certs don't work
+          cmd_exe = File.expand_path(File.join(::UBSAFE_ROOT, 'bin','ubsafe_scp_cmd.expect'))
+          full_cmd = "#{cmd_exe} #{ssh_user}@#{ssh_host} \"#{ssh_password}\" #{source_file} #{destination_dir}"
+          masked_full_cmd = "#{cmd_exe} #{ssh_user}@#{ssh_host} [PASSWORD] #{source_file} #{destination_dir}"
+        else
+          # Certs assumed if no password
+          full_cmd = "scp #{source_file} #{ssh_user}@#{ssh_host}:#{destination_dir}"
+          masked_full_cmd = full_cmd
+        end
+        #puts "About to issue \"#{full_cmd}\""
+        cmd_output = `#{full_cmd}`
+        cmd_status = $?
+        @log.debug("Executed scp status #{cmd_status} command \"#{masked_full_cmd}\"")
+        cmd_output_lines = cmd_output.split("\n").reject {|line| line =~ /spawn/i or line =~ /password/i }
+        cmd_output_cleaned = []
+        cmd_output_lines.each do |cmd_output_line|
+          cmd_output_cleaned << cmd_output_line.strip.chomp
+        end
+        cmd_status = cmd_status == 0 ? :success : :failure
+        return [cmd_status,cmd_output_cleaned]
+      end
+      
+      ##
+      # Does remote file exist?
+      #
+      # @param [Hash] backup_options
+      # @param [String] backup_name
+      # @return [Boolean] true or false
+      #
+      def remote_file_exists?(remote_file_name = nil,backup_options = nil,backup_name = nil)
+        backup_options ||= @backup_options
+        backup_name ||= @backup_name
+        if remote_file_name
+          remote_directory_name = File.dirname(remote_file_name)
+        else  
+          backup_file_name = get_backup_file_name(backup_options)
+          remote_directory_name = File.join(backup_options[:base_backup_directory],backup_name)
+          remote_file_name = File.join(remote_directory_name,backup_file_name)
+        end
+        remote_bin_dir = backup_options[:bin_dir] ? "#{backup_options[:bin_dir]}/" : ''
+        remote_cmd = "#{remote_bin_dir}ubsafe_file_exists #{remote_file_name}"
+        cmd_status, cmd_output = ssh_cmd(remote_cmd)
+        if cmd_status == :failure or cmd_output[0].chomp.strip == '1'
+          return false
+        end
+        
+        # remote_cmd = "ls #{remote_directory_name}"
+        # #puts "remote_file_exists? Looking for #{remote_directory_name}"
+        # cmd_status, cmd_output = ssh_cmd(remote_cmd)
+        # if cmd_status == :failure or cmd_output.join("\n") =~ /no\ssuch/i
+        #   #puts "remote_file_exists? #{remote_directory_name} does not exist"
+        #   return false
+        # else
+        #   remote_cmd = "ls #{remote_file_name}"
+        #   #puts "remote_file_exists? Looking for #{remote_file_name}"
+        #   cmd_status, cmd_output = ssh_cmd(remote_cmd)
+        #   #puts "remote_file_exists? cmd_status #{cmd_status}"
+        #   if cmd_status == :failure or cmd_output.join("\n") =~ /no\ssuch/i
+        #     #puts "remote_file_exists? #{remote_file_name} does not exist"
+        #     return false
+        #   end
+        # end
+        
+        return true
+      end
+      
+    end
+    
+  end
+  
+  
+end