syc-backup 0.0.4

data/lib/backup/options.rb

@@ -0,0 +1,199 @@
+require 'optparse'
+require_relative '../backup_version'
+
+module Backup
+
+  # Parses the command line options the user has provided on the command line
+  class Options
+    # If the user doesn't provide a backup folder a default folder is used
+    DEFAULT_BACKUP_FOLDER = File.expand_path("~/backup/")
+    
+    # Retrieve the database name that has to be backed up
+    attr_reader :database
+    # The user that is allowed to access the database
+    attr_reader :user
+    # The user's password to access the database
+    attr_reader :password
+    # The files to be backed up
+    attr_reader :files
+    # The backup directory where the files to be backed up 
+    attr_reader :backup_folder
+    # Determines whether the backup folder to be overridden when already exists 
+    attr_reader :override
+    # The cron schedule
+    attr_reader :cron
+    # Determines whether to compress the backup if not to compress it returns
+    # false, otherwise true
+    attr_reader :no_compress
+
+    # Takes the arguments from the command line and parses them
+    def initialize(argv)
+      @exit_code = 0
+      init_exit_messages
+      parse(argv)
+    end
+
+    private
+
+    # Initializes the error messages belonging to the error codes
+    def init_exit_messages
+      @exit_message = {"1"  => "Database missing", 
+                       "2"  => "User missing", 
+                       "4"  => "Password missing",
+                       "8"  => "Invalid cron data",
+                       "16" => "Missing database or files"}
+    end
+
+    # Checks the values provided in the array c whether they are valid cron 
+    # values representing one of the values minute, hour, day of month, 
+    # month or day of week. Allowed values are
+    #   minute         0..59, *
+    #   hour           0..23, *
+    #   day of month   1..31, *
+    #   month          1..12, *
+    #   day of week    1..7 , *
+    # If invalid values are detected bit 3 of exit_code is set and nil is
+    # returned. Otherwise a cron time string like "30 3 * * *" is returned.
+    def validate_cron_values(c)
+      cron_values = [0..59, 0..23, 1..31, 1..12, 1..7]
+      c.each.with_index do |v,i|
+        v.split(/,/).each do |s|
+          unless cron_values[i].cover?(s.to_i) or s == '*'
+            @exit_code |= 0b1000 
+            return nil
+          end
+        end
+      end
+      c.fill('*', c.size..4)
+      c.join(' ')
+    end
+
+    # Check if all requested arguments are provided. If arguments are missing a
+    # exit code not equal to 0 is set. Following exit codes are set
+    #   Argument          Exit code
+    #   database           00001
+    #   user               00010
+    #   password           00100
+    #   cron               01000
+    #   files and database 10000
+    # If for instance the database and the user is missing the exit code will
+    # return 3. And can be caught with
+    #   begin
+    #     opts = Options.new(ARGV)
+    #   rescue ExitStatus => e
+    #     puts "database missing"                 if e.status == 1
+    #     puts "user missing"                     if e.status == 2
+    #     puts "password missing"                 if e.status == 4
+    #     puts "cron invalid"                     if e.status == 8
+    #     puts "ether database or files required" if e.status == 16
+    #   end
+    def check_for_missing_arguments
+      if not @database and not @files
+        @exit_code |= 0b10000
+      elsif @database or @user or @password
+        @exit_code |= 0b00001 unless @database
+        @exit_code |= 0b00010 unless @user
+        @exit_code |= 0b00100 unless @password
+      end
+    end
+
+    # Initializes values as the backup folder with a default value if not
+    # provided by the user
+    def initialize_default_arguments_if_missing
+      @backup_folder = DEFAULT_BACKUP_FOLDER unless @backup_folder
+      unless @override
+        timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+        if @backup_folder and File.exists?(@backup_folder)
+          @backup_folder = File.dirname(@backup_folder) + '/' +
+                           File.basename(@backup_folder) + '_' + timestamp
+        end
+      end
+      @backup_folder = File.expand_path(@backup_folder)
+      @backup_folder += '/' unless @backup_folder.match(/.*\/\Z/)
+    end
+
+    # Parses the user input and initializes the application
+    def parse(argv)
+
+      OptionParser.new do |opts|
+        app_name = File.basename($PROGRAM_NAME)
+        opts.banner = "Backup files and a database to a backup folder\n\n"+
+                      "Usage: #{app_name} [options] [backup_folder]"
+
+        opts.on("-d", "--database DATABASE", "Database to backup") do |d|
+          @database = d
+        end
+
+        opts.on("-u", "--user USER", "User of the database") do |u|
+          @user = u
+        end
+        
+        opts.on("-p", "--password PASSWORD", 
+                "User's password to access the database") do |p|
+          @password = p
+        end
+
+        opts.on("-f", "--file f1,f2,f3", Array,
+                "A list of files to backup") do |f|
+          @files = f.map {|f| f.strip}
+        end
+
+        opts.on("--no-compress",
+                "Do not compress the backed up files",
+                "and database") do |n|
+          @no_compress = true
+        end
+
+        opts.on("--override", "Override the backup folder if it exists") do |o|
+          @override = true
+        end
+
+        opts.on("--cron 'm h dom m dow'", String,
+                "Create a cron job that automatically ",
+                "invokes #{app_name}",
+                "m   = minute        0..59",
+                "h   = hour          0..23",
+                "dom = day of month  1..31",
+                "m   = month         1..12",
+                "dow = day of week   1..7",
+                "30 3 * * * will run the cron job at 3:30am") do |c|
+          @cron = validate_cron_values c.split(/ /).slice(0..4)
+        end
+
+        opts.on("-v", "--version", "Show version") do |v|
+          puts Backup::VERSION
+          exit 0
+        end
+
+        opts.on("-h", "--help", "Show this message") do |h|
+          puts opts
+          exit 0
+        end
+
+        begin
+          opts.parse!(argv)
+        rescue OptionParser::ParseError => e
+          STDERR.puts e.message, "\n", opts
+          exit(-1)
+        end
+
+        @backup_folder = argv.shift
+
+        check_for_missing_arguments
+
+        @exit_code.size.times do |i|
+          result = @exit_code & 0b00001 << i
+          STDERR.puts @exit_message[result.to_s] if result > 0
+        end
+        
+        if @exit_code > 0
+          puts opts
+          exit(@exit_code) 
+        end
+        
+        initialize_default_arguments_if_missing 
+      end
+
+    end
+  end
+end

data/lib/backup/process.rb

@@ -0,0 +1,99 @@
+require 'open3'
+require 'fileutils'
+
+# The module Backup provides functions to backup MySQL databases and files and
+# folders. The backup will be compressed to a default or a specified backup
+# folder. Rather than backing up the files a cron job can be scheduled 
+# invoking the provided command.
+module Backup
+
+  # Conducts the backups of a MySQL database and files.
+  class Process
+
+    # Takes the backup_folder where the files are backed up to. If override is
+    # provided the files in the backup folder are overridden. no_compress will
+    # prevent compressing the backed up files and will just copy them to the
+    # provided backup folder
+    def initialize(backup_folder, files, override, no_compress)
+      @backup_folder = backup_folder
+      @files = files
+      @override = override
+      @no_compress = no_compress
+    end
+
+    # Creates the backup of the database and the files. If at least one of the
+    # provided files doesn't exist the application will print an error message
+    # with the inexistent files and terminates
+    def backup
+      inexistent_files = check_for_inexistent_files
+      unless inexistent_files.empty?
+        STDERR.puts "Cannot backup inexistent files"
+        STDERR.puts inexistent_files.join(" ")
+        exit 1
+      end
+
+      FileUtils.mkdir_p @backup_folder unless File.exists? @backup_folder
+
+      if @no_compress 
+        copy_files 
+      else
+        compress_files_and_copy
+      end
+
+    end
+
+    private
+
+    # Checks if files to backup have been provided that don't exist. Returns the
+    # inexistent files
+    def check_for_inexistent_files
+      inexistent_files = []
+      @files.each do |file|
+        inexistent_files << file unless File.exists? file
+      end
+
+      inexistent_files
+    end
+
+    # Copies the files to the backup folder. Is only invoked if --no-compress
+    # is provided
+    def copy_files
+      @files.each do |file|
+        basename = File.basename file
+        FileUtils.cp file, @backup_folder + basename if File.file? file
+        FileUtils.cp_r file, @backup_folder + basename if File.directory? file
+      end
+    end
+
+    # Compresses the files and copies the compressed file to the backup folder.
+    # The compression is done with
+    #
+    #     tar cfz backup_folder/YYYYmmdd-HHMMSS_syc-backup.tar.gz
+    #
+    # If an error occurs while compressing the error message of tar is
+    # displayed and the application exits. If the method runs without errors
+    # the tar file is returned
+    def compress_files_and_copy
+      timestamp = ""
+      unless @override
+       timestamp = Time.now.strftime("%Y%m%d-%H%M%S") + '_'
+      end
+      tar_file = @backup_folder + timestamp + "syc-backup.tar.gz" 
+      tar_command = "tar cfz #{tar_file} #{@files.join(" ")}"
+
+      stdout, stderr, status = Open3.capture3(tar_command)
+
+      unless status.exitstatus == 0
+        STDERR.puts "There was a problem executing command"
+        STDERR.puts tar_command
+        STDERR.puts stderr
+        exit status.exitstatus
+      end
+
+      tar_file
+    end
+
+  end
+
+end
+

data/lib/backup/runner.rb

@@ -0,0 +1,79 @@
+require_relative 'options'
+require_relative 'mysql_backup'
+require_relative 'cron_edit'
+require_relative 'process'
+require_relative 'environment'
+
+module Backup
+
+  # Is invoked from the command line application and invokes the application's
+  # optons as provided by the user on the command line
+  class Runner
+
+    # Takes the command line options and parses them
+    def initialize(argv)
+      @options = Options.new(argv)
+    end
+
+    # Operates on the options and invokes the respective functions
+    def run
+      if @options.cron
+        create_cron
+      else
+        create_backup
+      end
+    end
+
+    private
+
+    # Creates a cron job based on the provided options and the schedule
+    # provided with the --cron flag
+    def create_cron
+      cron_edit = CronEdit.new
+      command = cron_edit.add_command create_cron_command, Environment.ruby
+      puts "--> added command to cron"
+      puts "    #{command}"
+    end
+
+    # Creates the cron command based on the options provided by the user.
+    def create_cron_command
+      command = @options.cron + " sycbackup #{@options.backup_folder}"
+      command += ' -d ' + @options.database + 
+                 ' -u'  + @options.user + 
+                 ' -p'  + @options.password if @options.database
+      command += ' -f ' + @options.files.join(',') if @options.files
+      command += ' --no-compress' if @options.no_compress
+      command += ' --override' if @options.override
+
+      command
+    end
+
+    # Backs up the files provided by the user on the command line. Provides a
+    # summary of the backed up files
+    def create_backup
+      files = []
+      if @options.database
+        db_backup = MySQLBackup.new(@options.database, 
+                                    @options.user,
+                                    @options.password)
+        files << db_backup.backup
+      end
+      
+      files << @options.files if @options.files
+
+      files.flatten!
+
+      process = Process.new(@options.backup_folder,
+                            files, 
+                            @options.override, 
+                            @options.no_compress)
+      process.backup
+      puts "--> backed up files"
+      puts "    #{files.join("\n    ")}"
+      puts "--> to #{@options.backup_folder}"
+
+      File.delete files[0] if @options.database
+    end
+
+  end
+end

data/lib/backup_version.rb

@@ -0,0 +1,9 @@
+# Backup contains functions to backup a MySQL database and files and directories
+# to a default or specified backup directory. Instead of instant backup the
+# invoked command can be added to a crontab and invoked based on the provided
+# schedule that is a parameter of the --cron option. The backed up files are
+# per default compressed but this can be ommitted
+module Backup
+  # Version of the application
+  VERSION = '0.0.4'
+end

data/sycbackup.gemspec

@@ -0,0 +1,20 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require 'backup_version'
+
+Gem::Specification.new do |s|
+  s.name         = "syc-backup"
+  s.summary      = %q{Back up a database and files}
+  s.description  = %q{Back up a database and files or schedule cron job 
+                      for backup}
+  s.requirements = ['No requirements']
+  s.version      = Backup::VERSION
+  s.author       = "Pierre Sugar"
+  s.email        = "pierre@sugaryourcoffee.de"
+  s.homepage     = "http://syc.dyndns.org/drupal"
+  s.platform     = Gem::Platform::RUBY
+  s.required_ruby_version = '>=1.9'
+  s.files        = Dir['**/**']
+  s.executables  = ['sycbackup']
+  s.test_files   = Dir['test/test*.rb']
+  s.has_rdoc     = true
+end

data/test/test_cron_edit.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'shoulda'
+require_relative '../lib/backup/cron_edit.rb'
+
+# Test for CronEdit will add commands to the users crontab. After each test
+# the test entries are removed. So the crontab should not be changed after a
+# test.
+# In case of changes to CronEdit that will lead to a system exit it might leave
+# the crontab with test data. In that case you have to remove the test data 
+# manually. But subsequent successfull runs should remove all test entries.
+class TestCronEdit < Test::Unit::TestCase
+
+  context "Crontab operation" do
+
+    # Determines the count of the provided _command_ in the crontab.
+    def crontab_count(command)
+      content = `crontab -l`
+      count = 0
+      content.split(/\n/).each do |c|
+        count += 1 if c == command
+      end
+      count
+    end
+
+    # Adds a command to crontab and checks that it is entered. Removes command
+    # after test.
+    should "add command to crontab" do
+      ce = Backup::CronEdit.new
+      command = "1 2 * * * ls -l"
+      ce.add_command command
+      assert_equal 1, crontab_count(command)
+      ce.remove_command command
+      assert_equal 0, crontab_count(command)
+    end
+    
+    # Adds a command twice to crontab and expects that it is contained only
+    # once. Removes added command at end of test
+    should "not add duplicate command to crontab" do
+      ce = Backup::CronEdit.new
+      command = "2 2 2 * * syc-backup -d test -upierre -ppass"
+      ce.add_command command
+      assert_equal 1, crontab_count(command)
+      ce.add_command command
+      assert_equal 1, crontab_count(command)
+      ce.remove_command command
+      assert_equal 0, crontab_count(command)
+    end
+  end
+end