server_backups 0.1.8

data/bin/server_backup

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir if File.directory?(lib_dir)
+
+require 'server_backups'
+require 'main'
+require 'tmpdir'
+
+def find_time_zone(name)
+    ActiveSupport::TimeZone.all.select do |zone|
+        name.casecmp(zone.name).zero? || name.casecmp(zone.tzinfo.name).zero?
+    end.first
+end
+
+ERRORS = []
+def backup_thread
+    Thread.new do
+        begin
+            Dir.mktmpdir do |tmp_dir|
+                yield tmp_dir
+            end
+        rescue StandardError => error
+            ERRORS << error
+        end
+    end
+end
+
+def handle_errors(config_path)
+    notifier = ServerBackups::Notifier.new(config_path)
+    if ERRORS.empty?
+        notifier.notify_success
+        puts "That's the jam"
+    else
+        notifier.notify_failure(ERRORS)
+        puts "borthnarg" * 15
+        puts ERRORS.inspect
+    end
+end
+
+def run_backups(backup_type, config_file, database, db_only, files_only)
+    website_backup = unless db_only
+                         backup_thread do |tmp_dir|
+                             ServerBackups::WebsiteBackup.new(config_file,
+                                                              tmp_dir, backup_type).do_backup
+                         end
+                     end
+    database_backup = unless files_only
+                          backup_thread do |tmp_dir|
+                              ServerBackups::MysqlBackup.send(backup_type,
+                                                              config_file,
+                                                              tmp_dir, database).do_backup
+                          end
+                      end
+    [website_backup, database_backup].compact.each(&:join)
+    handle_errors(config_file)
+    exit_success!
+end
+
+def run_restore(config_file, database, up_to, tz, db_only, files_only)
+    Chronic.time_class = find_time_zone(tz) if tz
+    up_to = Chronic.parse(up_to)
+    website_restore = unless db_only
+                          backup_thread do |tmp_dir|
+                              ServerBackups::WebsiteRestore.new(config_file,
+                                                                tmp_dir, up_to).do_restore
+                          end
+                      end
+    database_restore = unless files_only
+                           backup_thread do |tmp_dir|
+                               ServerBackups::MysqlRestore.restore(config_file,
+                                                                   tmp_dir,
+                                                                   up_to, database)
+                           end
+                       end
+    [website_restore, database_restore].compact.each(&:join)
+    exit_success!
+end
+
+def time_zone_match?(pattern, timezone)
+    pattern =~ timezone.name || pattern =~ timezone.tzinfo.name
+end
+
+Main do
+    option 'config', 'c' do
+        argument :required
+        description 'load configuration from YAML file'
+        defaults '~/.backup_conf.yml'
+    end
+
+    option 'database', 'd' do
+        argument :required
+        description 'Which database to back up, defaults to all non-system databases.'
+        defaults 'all'
+    end
+
+    option 'db_only', 'b' do
+        argument :optional
+        description 'Only work with database(s).'
+    end
+
+    option 'files_only', 'f' do
+        argument :optional
+        description 'Only work with files.'
+    end
+
+    mode 'restore' do
+        params[:backup_type].ignore!
+        option 'up_to', 'u' do
+            argument :required
+            description 'The point in time to restore to.  See ' \
+                        'https://github.com/mojombo/chronic for examples.'
+        end
+        option 'time_zone', 'z' do
+            argument :required
+            description 'Time zone that <up_to> is given in. Default: time_zone from config file.'
+        end
+        def run
+            options = params.to_options
+            run_restore(*options.slice('config',
+                                       'database',
+                                       'up_to',
+                                       'time_zone',
+                                       'db_only',
+                                       'files_only').values)
+        end
+    end
+
+    mode 'zones' do
+        params[:backup_type].ignore!
+        argument 'search' do
+            argument :required
+            description "Add a regex pattern to search for, e.g. '*america*'"
+            defaults '.*'
+        end
+
+        def run
+            pattern = Regexp.new(params['search'].value, 'i')
+            ActiveSupport::TimeZone.all.sort_by(&:name).each do |timezone|
+                if time_zone_match?(pattern, timezone)
+                    puts timezone.name + "\t\t" + timezone.tzinfo.name
+                end
+            end
+        end
+    end
+
+    argument 'backup_type' do
+        cast :symbol
+        validate { |command| ServerBackups::BackupBase::BACKUP_TYPES.include? command }
+        description 'specifies the backup type to perform [incremental | daily | weekly | monthly]'
+    end
+
+    def run
+        options = params.to_options
+        run_backups(*options.slice('backup_type',
+                                   'config',
+                                   'database',
+                                   'db_only',
+                                   'files_only').values)
+    end
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/crontab.txt

@@ -0,0 +1,4 @@
+5 0 1 * * server_backup monthly
+5 0 2-31 * 0 server_backup weekly
+5 0 2-31 * 1-6 server_backup daily
+5 1-23 * * * server_backup incremental

data/lib/server_backups/backup_base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module ServerBackups
+    class BackupBase
+        attr_reader :working_directory, :config, :logger, :s3, :backup_type
+
+        BACKUP_TYPES = %i[incremental daily weekly monthly].freeze
+
+        TIMESTAMP_FORMAT = '%Y-%m-%dT%H00.UTC%z'
+
+        def initialize(config_file, working_directory, backup_type)
+            @working_directory = working_directory
+            @config = Config.new(config_file)
+            Time.zone = config.time_zone
+            @logger = config.logger
+            @backup_type = backup_type.to_sym
+            logger.debug "Initialized #{backup_type} #{self.class.name.demodulize.titleize}, " \
+                         "prefix: '#{s3_prefix}'"
+        end
+
+        def incremental?
+            backup_type == :incremental
+        end
+
+        class << self
+            def daily(config_file, working_directory)
+                new(config_file, working_directory, :daily)
+            end
+
+            def weekly(config_file, working_directory)
+                new(config_file, working_directory, :weekly)
+            end
+
+            def monthly(config_file, working_directory)
+                new(config_file, working_directory, :monthly)
+            end
+
+            def incremental(config_file, working_directory)
+                new(config_file, working_directory, :incremental)
+            end
+        end
+
+        def backup_filename
+            "#{self.class.name.demodulize.underscore}.#{backup_type}.#{timestamp}.tgz"
+        end
+
+        def title
+            self.class.name.demodulize.titleize
+        end
+
+        def take_backup
+            logger.info "Creating #{backup_type} #{title} #{create_archive_command}"
+
+            system create_archive_command
+            unless last_command_succeeded?
+                raise BackupCreationError.new("Received #{$CHILD_STATUS} from tar command.",
+                                              self.class, backup_type)
+            end
+            logger.debug "Backup exited with #{$CHILD_STATUS}"
+        end
+
+        def s3_prefix
+            File.join(config.prefix, self.class.name.demodulize.underscore,
+                      backup_type.to_s, '/')
+        end
+
+        def backup_s3_key
+            File.join(s3_prefix, File.basename(backup_filename))
+        end
+
+        def store_backup
+            logger.info 'Upload file'
+            @uploaded_file = s3.save backup_path, backup_s3_key
+            logger.info 'Finished uploading file.'
+        end
+
+        def remove_old_backups
+            s3.delete_files_not_newer_than s3_prefix, config.get_retention_threshold(backup_type)
+        end
+
+        def backup_path
+            File.join(working_directory, backup_filename)
+        end
+
+        def do_backup
+            load_resources
+            take_backup
+            store_backup
+            # verify_backup
+            remove_old_backups
+        end
+
+        def timestamp
+            Time.zone.now.strftime(TIMESTAMP_FORMAT)
+        end
+
+        def load_resources
+            # @mysql = Mys3ql::Mysql.new self.config
+            @s3 = S3.new config
+        end
+
+        private
+
+        def last_command_succeeded?
+            $CHILD_STATUS.exitstatus.zero?
+        end
+    end
+end

data/lib/server_backups/config.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# lifted from https://github.com/airblade/mys3ql/blob/master/lib/mys3ql/config.rb
+
+require 'yaml'
+require 'logger'
+
+module ServerBackups
+    class Config
+        attr_reader :logger, :logging, :config_file
+
+        DEFAULT_LOGFILE_SIZE = 1.megabytes
+        DEFAULT_LOGFILE_COUNT = 7
+
+        def initialize(config_file = nil)
+            @config_file = config_file || default_config_file
+            @config = YAML.load_file File.expand_path(config_file)
+            @logging = @config['logging']
+            @logger = Logger.new(log_device, logfile_count, logfile_size)
+        rescue Errno::ENOENT
+            warn "missing config file #{config_file}"
+            exit 1
+        end
+
+        class << self
+            def get_time_zone(name)
+                ActiveSupport::TimeZone.all.find do |time_zone|
+                    time_zone.name.casecmp(name).zero? || time_zone.tzinfo.name.casecmp(name).zero?
+                end
+            end
+        end
+
+        def slack_webhook
+            @config.fetch('slack', nil)&.fetch('webhook')
+        end
+
+        def notify_on_success
+            @config.fetch('slack', nil)&.fetch('notify_on_success', false)
+        end
+
+        def slack_mention_on_failure
+            @config.fetch('slack', nil)&.fetch('mention_users_on_failure', [])
+        end
+
+        def slack_mention_on_success
+            @config.fetch('slack', nil)&.fetch('mention_users_on_success', [])
+        end
+
+        #
+        # General
+        #
+        FILE_LOCATION = '/var/www'
+
+        def web_root
+            File.absolute_path(@config['file_location'] || FILE_LOCATION)
+        end
+
+        def time_zone
+            @config['time_zone'] || 'UTC'
+        end
+
+        def system_time_zone
+            tz = if @config['system_time_zone']
+                     @config['system_time_zone']
+                 elsif File.exist?('/etc/timezone')
+                     File.read('/etc/timezone')
+                 elsif File.exist?('/etc/localtime')
+                     %r{([\w_]+\/[\w_]+)$}.match(`ls -l /etc/localtime`).captures.first
+                 else
+                     'UTC'
+                 end
+            self.class.get_time_zone(tz)
+        end
+
+        def log_device
+            logging['use_stdout'] == true ? STDOUT : logging['logfile_path']
+        end
+
+        def logfile_size
+            if logging['file_size']
+                unit, quantity = @logging['file_size'].first
+                quantity = quantity.to_i
+                quantity.send(unit)
+            else
+                DEFAULT_LOGFILE_SIZE
+            end
+        end
+
+        def logfile_count
+            if logging['keep_files']
+                logging['keep_files'].to_i
+            else
+                DEFAULT_LOGFILE_COUNT
+            end
+        end
+
+        def get_retention_threshold(backup_type)
+            interval, quantity = @config['retention'][backup_type.to_s].first
+            quantity = quantity.to_i + 1
+            quantity.send(interval).ago
+        end
+
+        def retain_dailies_after
+            get_retention_threshold(:daily)
+        end
+
+        def retain_incrementals_after
+            get_retention_threshold(:incremental)
+        end
+
+        def retain_monthlies_after
+            get_retention_threshold(:monthly)
+        end
+
+        def retain_weeklies_after
+            get_retention_threshold(:weekly)
+        end
+
+        #
+        # MySQL
+        #
+
+        def user
+            mysql['user']
+        end
+
+        def password
+            mysql['password']
+        end
+
+        def database
+            mysql['database']
+        end
+
+        def bin_path
+            mysql['bin_path']
+        end
+
+        def bin_log
+            mysql['bin_log']
+        end
+
+        MYSQLDUMP = 'mysqldump'
+        MYSQL = 'mysql'
+        MYSQLBINLOG = 'mysqlbinlog'
+
+        def mysqldump_bin
+            File.join(bin_path, MYSQLDUMP)
+        end
+
+        def mysqlbinlog_bin
+            File.join(bin_path, MYSQLBINLOG)
+        end
+
+        def mysql_bin
+            File.join(bin_path, MYSQL)
+        end
+
+        #
+        # S3
+        #
+
+        def access_key_id
+            s3['access_key_id']
+        end
+
+        def secret_access_key
+            s3['secret_access_key']
+        end
+
+        def bucket
+            s3['bucket']
+        end
+
+        def region
+            s3['region']
+        end
+
+        def prefix
+            s3['prefix']
+        end
+
+        private
+
+        def mysql
+            @config['mysql']
+        end
+
+        def s3
+            @config['s3']
+        end
+
+        def default_config_file
+            File.join (ENV['HOME']).to_s, '.mys3ql'
+        end
+    end
+end

data/lib/server_backups/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ServerBackups
+    class BackupCreationError < StandardError
+        attr_reader :backup_class, :backup_type
+        def initialize(msg, backup_class, backup_type)
+            @backup_class = backup_class
+            @backup_type = backup_type
+            super(msg)
+        end
+    end
+
+    class RestoreTarError < BackupCreationError; end
+end

data/lib/server_backups/mysql_backup.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ServerBackups
+    class MysqlBackup < BackupBase
+        attr_reader :database_name
+
+        SYSTEM_DATABASES = %w[sys information_schema mysql performance_schema].freeze
+
+        def initialize(config_file, working_directory, backup_type, database_name)
+            @database_name = database_name
+            super(config_file, working_directory, backup_type)
+        end
+
+        def do_backup
+            if database_name == 'all'
+                backup_all_databases
+            else
+                super
+            end
+        end
+
+        def backup_all_databases
+            @database_name = 'mysql'
+            all_databases.each do |database|
+                self.class.send(backup_type,
+                                config.config_file,
+                                working_directory,
+                                database).do_backup
+            end
+        end
+
+        class << self
+            def daily(config_file, working_directory, database_name)
+                new(config_file, working_directory, :daily, database_name)
+            end
+
+            def weekly(config_file, working_directory, database_name)
+                new(config_file, working_directory, :weekly, database_name)
+            end
+
+            def monthly(config_file, working_directory, database_name)
+                new(config_file, working_directory, :monthly, database_name)
+            end
+
+            def incremental(config_file, working_directory, database_name)
+                MysqlIncrementalBackup.new(config_file, working_directory, database_name)
+            end
+        end
+
+        def create_archive_command
+            cmd = config.mysqldump_bin + ' --quick --single-transaction --create-options '
+            cmd += ' --flush-logs --master-data=2 --delete-master-logs ' if binary_logging?
+            cmd + cli_options + ' | gzip > ' + backup_path
+        end
+
+        def s3_prefix
+            File.join(config.prefix, self.class.name.demodulize.underscore,
+                      database_name, backup_type.to_s, '/')
+        end
+
+        def backup_filename
+            "mysql_backup.#{backup_type}.#{timestamp}.sql.gz"
+        end
+
+        def all_databases
+            execute_sql('show databases;').reject do |db_name|
+                db_name.in?(SYSTEM_DATABASES)
+            end
+        end
+
+        private
+
+        def binary_logging?
+            !config.bin_log.blank?
+        end
+
+        def cli_options
+            cmd = config.password.blank? ? '' : " -p'#{config.password}' "
+            cmd + " -u'#{config.user}' " + database_name
+        end
+
+        def execute_sql(sql)
+            cmd = "#{config.mysql_bin} --silent --skip-column-names -e \"#{sql}\" #{cli_options}"
+            logger.debug "Executing raw SQL against #{database_name}\n#{cmd}"
+            output = `#{cmd}`
+            logger.debug "Returned #{$CHILD_STATUS.inspect}. STDOUT was:\n#{output}"
+            output.split("\n") unless output.blank?
+        end
+    end
+end

data/lib/server_backups/mysql_incremental_backup.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ServerBackups
+    class MysqlIncrementalBackup < MysqlBackup
+        def initialize(config_file, working_directory, database_name)
+            database_name = 'mysql' if database_name == 'all'
+
+            super(config_file, working_directory, :incremental, database_name)
+        end
+
+        class BinlogFilename
+            attr_reader :path
+            def initialize(path)
+                @path = path
+            end
+
+            def log_index
+                /(\d{6})/.match(File.basename(path)).captures.first
+            end
+        end
+
+        def do_backup
+            load_resources
+            flush_logs
+            each_bin_log do |file|
+                index = BinlogFilename.new(file).log_index
+                next if index.in?(already_stored_log_indexes)
+                backup_single_bin_log(file)
+            end
+        end
+
+        def s3_prefix
+            File.join(config.prefix, 'mysql_backup', 'incremental', '/')
+        end
+
+        def flush_logs
+            execute_sql('flush logs;')
+        end
+
+        def each_bin_log
+            # execute 'flush logs'
+            logs = Dir.glob("#{config.bin_log}.[0-9]*").sort_by { |f| f[/\d+/].to_i }
+            logs_to_backup = logs[0..-2] # all logs except the last, which is in use
+            logs_to_backup.each do |log_file|
+                yield log_file
+            end
+        end
+
+        # def each_remote_bin_log
+        #     remote_bin_logs.each do |file|
+        #         yield(**parse_remote_binlog_filename(file))
+        #     end
+        # end
+
+        # def parse_remote_binlog_filename(file)
+        #     filename = File.basename(file.key)
+        #     prefix, index, timestamp = REMOTE_FILENAME_REGEX.match(filename).captures
+        #     {
+        #         key: file.key,
+        #         file: file,
+        #         prefix: prefix,
+        #         index: index,
+        #         timestamp: timestamp,
+        #         datetime: Time.zone.strptime(timestamp, TIMESTAMP_FORMAT)
+        #     }
+        # end
+
+        private
+
+        REMOTE_FILENAME_REGEX = /(.*)\.(\d+)\.(.{15})/
+        def already_stored_log_indexes
+            remote_bin_logs.map do |s3object|
+                _, index = REMOTE_FILENAME_REGEX.match(s3object.key).captures
+                index
+            end
+        end
+
+        def remote_bin_logs
+            s3.bucket.objects(prefix: s3_prefix)
+        end
+
+        def backup_single_bin_log(file)
+            logger.debug "Backing up #{file}."
+            dest_filename = File.basename(file) + '.' + timestamp
+            logger.info "Storing #{file} to #{dest_filename}"
+            s3.save file, File.join(s3_prefix, dest_filename)
+        end
+    end
+end