Cross Reference: /ontohub/script/backup

	backup revision 5efadb4662f2a63d5f5f1a5b303ab7c3371069a8
200N/A#!/usr/bin/env ruby
200N/A
200N/Arequire 'fileutils'
200N/Arequire 'pathname'
200N/A
200N/Amodule Backup
200N/A  class Backup
200N/A    # Amount of backups that have to be there at least
200N/A    BACKUPS_COUNT = 3
200N/A    # Backups are valid for 7 days
200N/A    BACKUPS_VALIDITY_TIME = 7 * 60 * 60 * 24
200N/A
200N/A    MAINTENANCE_FILE = 'maintenance.txt'
200N/A
200N/A    SQL_DUMP_FILE = 'ontohub_sql_dump.postgresql'
200N/A    REPOSITORY_FILE = 'ontohub_repositories.tar.gz'
200N/A
200N/A    DATA_DIRS = %w(data/repositories data/git_daemon)
200N/A
200N/A    attr_reader :db_name, :data_root, :backup_root, :backup_instance_dir
3704N/A    attr_reader :dry_run, :verbose, :sql_dump_without_su
200N/A
3866N/A    def initialize(db_name, data_root, backup_root,
200N/A      verbose: false, dry_run: true, sql_dump_without_su: false)
3866N/A      @db_name = db_name
3661N/A      @data_root = Pathname.new(data_root)
3866N/A      @backup_root = Pathname.new(backup_root)
3866N/A
464N/A      @dry_run = dry_run
3866N/A      @verbose = verbose
3866N/A      @sql_dump_without_su = sql_dump_without_su
200N/A    end
200N/A
3866N/A    def create
3866N/A      enable_maintenance_mode
3866N/A      initialize_backup
3866N/A      create_sql_dump
3866N/A      create_repository_archive
3866N/A      # We needed to create the directory for the script to continue later on.
3866N/A      Dir.rmdir(backup_instance_dir) if dry_run
200N/A      disable_maintenance_mode
200N/A      puts "created backup in #{backup_instance_dir}"
200N/A      self.class.prune(backup_root)
200N/A    end
200N/A
200N/A    def restore(backup_name)
200N/A      enable_maintenance_mode
200N/A      initialize_restore(backup_name)
200N/A      restore_sql_dump
200N/A      restore_repository_archive
200N/A      disable_maintenance_mode
200N/A      puts "restored backup from #{backup_instance_dir}"
200N/A    end
200N/A
200N/A    def self.prune(backup_root)
200N/A      if !Dir.exists?(backup_root)
200N/A        puts "Nothing to prune: There is no backup directory."
3866N/A        return
200N/A      end
200N/A      now = Time.now
200N/A      backup_dirs_allowed_to_delete(Dir.new(backup_root).entries).each do |dir|
200N/A        backup = backup_root.join(dir)
200N/A        if now - File.new(backup).ctime > BACKUPS_VALIDITY_TIME
200N/A          puts "removing old backup: #{dir}"
200N/A          FileUtils.rm_r(backup)
200N/A        end
3866N/A      end
3866N/A    end
200N/A
200N/A    protected
3866N/A
200N/A    def new_backup_name
903N/A      Time.now.strftime("%Y-%m-%d_%H-%M-%S")
3704N/A    end
3704N/A
3704N/A    def initialize_backup
3866N/A      @backup_instance_dir = backup_root.join(new_backup_name)
3866N/A      puts "FileUtils.mkdir_p #{backup_instance_dir}" if verbose
      # Create directory even in dry run to let the script continue.
      FileUtils.mkdir_p(backup_instance_dir)
    end

    def create_sql_dump
      Dir.chdir(backup_instance_dir) do
        if sql_dump_without_su
          exec "pg_dump -U postgres -Fc #{db_name} > #{SQL_DUMP_FILE}"
        else
          exec "sudo -u postgres pg_dump -Fc #{db_name} > #{SQL_DUMP_FILE}"
        end
      end
    end

    def create_repository_archive
      Dir.chdir(data_root.join('..')) do
        archive_file = backup_instance_dir.join(REPOSITORY_FILE)
        exec(["tar -czvf #{archive_file}", *DATA_DIRS].join(' '))
      end
    end

    def initialize_restore(backup_name)
      @backup_instance_dir = backup_root.join(backup_name)
      unless Dir.exists?(backup_instance_dir)
        puts "Error: Backup '#{backup_name}' does not exist in #{backup_root}."
        exit
      end
    end

    def restore_sql_dump
      Dir.chdir(backup_instance_dir) do
        if sql_dump_without_su
          exec "pg_restore -c -U postgres -d #{db_name} #{SQL_DUMP_FILE}"
        else
          exec "sudo -u postgres pg_restore -c -d #{db_name} #{SQL_DUMP_FILE}"
        end
      end
    end

    def restore_repository_archive
      Dir.chdir(data_root.join('..')) do
        puts "FileUtils.rm_r #{DATA_DIRS}" if verbose
        FileUtils.rm_r DATA_DIRS unless dry_run
        archive_file = backup_instance_dir.join(REPOSITORY_FILE)
        exec(["tar -xzvf #{archive_file}", *DATA_DIRS].join(' '))
      end
    end

    def enable_maintenance_mode
      puts "FileUtils.touch #{maintenance_file}" if verbose
      FileUtils.touch maintenance_file unless dry_run
    end

    def disable_maintenance_mode
      puts "FileUtils.rm #{maintenance_file}" if verbose
      FileUtils.rm maintenance_file unless dry_run
    end

    def exec(command)
      puts "[executing next command in #{Dir.getwd}]" if verbose
      puts command if verbose
      system(command) unless dry_run
    end

    def maintenance_file
      data_root.join(MAINTENANCE_FILE)
    end

    def self.backup_dirs_allowed_to_delete(entries)
      entries.reject{ |entry| %w(. ..).include?(entry) }[0..-(BACKUPS_COUNT+1)]
    end
  end
end

def data_root(rails_root)
  File.realpath(rails_root.join('data'))
end

def on_development_system?(rails_root)
  !File.symlink?(rails_root.join('data'))
end

# We assume, this script runs in "RAILS_ROOT/script/".
RAILS_ROOT = Pathname.new(__FILE__).dirname.join('..')

DATABASE = on_development_system?(RAILS_ROOT) ? 'ontohub_development' : 'ontohub'
BACKUP_ROOT = File.realpath('/home/ontohub/ontohub_data_backup')

backup = Backup::Backup.new(DATABASE, data_root(RAILS_ROOT), BACKUP_ROOT,
  sql_dump_without_su: on_development_system?(RAILS_ROOT),
  dry_run: false, verbose: true)

case ARGV.first
when 'create'
  backup.create
when 'restore'
  if ARGV.length == 1
    puts 'To restore a backup, you need to specify one with the arguments'
    puts '"restore backup_name"'
    exit
  end
  backup_name = ARGV[1]
  backup.restore(backup_name)
when 'prune'
  Backup::Backup.prune(BACKUP_ROOT)
else
  puts 'unknown or missing parameter'
  puts 'use parameter "create" or "restore <backup_name>" or "prune"'
  exit
end