pxcbackup 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c6bd1e6689acf97d87e4c7afa3ee9096fb730ea1
+  data.tar.gz: 182605c2e2341e9b453a667ad399441c27611235
+SHA512:
+  metadata.gz: 229b9f667f762529c9cd63e95a2f77bb79fa7e53fae577d4cde0fe2fdb5cfea711436981e11ce8da1655009abca45055640181a7234c53b32ca5aa8744a1277c
+  data.tar.gz: 3ebb735a23741bbff57790c9900855ab51277c7d931bf7ce55ade393fc0e86e8e3178a2d47a9712533be8506dd81c90d015d4519e0f48a2634962306950677c4

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2014 Robbert Klarenbeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,76 @@
+# PXCBackup
+
+PXCBackup is a database backup tool meant for [Percona XtraDB Cluster](http://www.percona.com/software/percona-xtradb-cluster) (PXC), although it could also be used on other related systems, like a [MariaDB](https://mariadb.org) [Galera](http://galeracluster.com/products/) cluster using [XtraBackup](http://www.percona.com/software/percona-xtrabackup), for example.
+
+The `innobackupex` script provided by Percona makes it very easy to create backups, however restoring backups can become quite complicated, since backups might need to be extracted, uncompressed, decrypted, before restoring they need to be prepared, incremental backups need to be applied on top of full backups, indexes might need to be rebuilt for compact backups, etc. Usually, backups need to be restored in stressful emergency situations, where all of these steps can slow you down quite a bit.
+
+PXCBackup does all of this for you! As a bonus, PXCBackup provides syncing backups to [Amazon S3](http://aws.amazon.com/s3/) and even restoring straight from S3.
+
+Since PXCBackup is meant for Galera clusters, it does a few additional things:
+
+* Run `innobackupex` with `--galera-info` and reconstructing `grastate.dat` when restoring a backup. This preserves the local node state, allowing new nodes to be added from a backup with just an IST!
+
+* Turning on `wsrep_desync` before a backup, and turning it off again after `wsrep_local_recv_queue` is empty. The reason for this is twofold:
+  * It prevents flow control from kicking in when the backup node takes a performance hit because of the increased disk load (this is similar to what happens on a donor node, during an SST).
+  * Secondly, it makes `clustercheck` report this node as unavailable, which can be very useful to let your loadbalancer(s) skip this node during the backup. This behavior can be turned off by setting `available_when_donor` to `1` in `clustercheck`.
+
+PXCBackup is basically a server command line tool, which means the following constraints were used:
+
+* Support ruby >= 1.8.7. Yes, 1.8.7 is EOL, but many cloud provider OS images still contain 1.8.7.
+* Have no external gem dependencies. This tool should be completely stand-alone, and only require certain command line tools.
+* Instead, execute command line tools. For example, it uses the `mysql` and `s3cmd` instead of modules / gems.
+
+## Installation
+
+Simply install the gem:
+
+```shell
+$ gem install pxcbackup
+```
+
+Of course, you need to have PXC (or similar) running, which provides most of the tools (`innobackupex`, `xtrabackup`, `xbstream`, `xbcrypt`).
+
+To sync to Amazon S3, make sure you have [S3cmd](http://s3tools.org/s3cmd) installed and configured (`s3cmd --configure`, which creates a file `~/.s3cfg`).
+
+## Usage
+
+Just check the built in command line help:
+
+```shell
+$ pxcbackup help
+```
+
+Aside from command line flags, you can specify additional options in `~/.pxcbackup`, or another
+config given by `-c`. Some commonly used settings are:
+
+```yaml
+backup_dir: /path/to/local/backups/
+remote: s3://my-aws-bucket/
+mysql_username: root
+mysql_password:
+compact: false
+compress: true
+encrypt: AES256
+encrypt_key: <secret-key>
+retention: 100
+desync_wait: 30
+threads: 4
+memory: 1G
+```
+
+## Wishlist
+
+* More complex rotation schemes
+* Separate rotation scheme for remote
+* Better error handling for shell commands
+* Code documentation (RDoc?)
+* Tests (RSpec?)
+* Different remote providers
+
+## Authors
+
+* Robbert Klarenbeek, <robbertkl@renbeek.nl>
+
+## License
+
+DeployHook is published under the [MIT License](http://www.opensource.org/licenses/mit-license.php).

data/bin/pxcbackup

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'pxcbackup'
+require 'pxcbackup/application'
+
+begin
+  PXCBackup::Application.new(ARGV).run
+rescue => e
+  abort "#{$0}: #{e.message}"
+end

data/lib/pxcbackup/application.rb

@@ -0,0 +1,95 @@
+require 'optparse'
+require 'time'
+require 'yaml'
+
+module PXCBackup
+  class Application
+    def initialize(argv)
+      parse_options(argv)
+
+      config = File.join(ENV['HOME'], '.pxcbackup')
+      if @options[:config]
+        config = @options[:config]
+        raise 'cannot find given config file' unless File.file?(config)
+      end
+      if File.file?(config)
+        config_options = YAML.load_file(config)
+        config_options = config_options.inject({}) { |hash, (k, v)| hash[k.to_sym] = v; hash }
+        @options = config_options.merge(@options)
+      end
+    end
+
+    def run
+      backupper = Backupper.new(@options)
+
+      case @command
+      when 'create'
+        backupper.make_backup(@options)
+      when 'list'
+        backupper.list_backups
+      when 'restore'
+        time = @arguments.any? ? Time.parse(@arguments.first) : Time.now
+        backupper.restore_backup(time, !!@options[:skip_confirmation])
+      end
+    end
+
+    def parse_options(argv)
+      @options ||= {}
+      parser = OptionParser.new do |opt|
+        opt.banner = "Usage: #{$0} COMMAND [OPTIONS]"
+        opt.separator ''
+        opt.separator 'Commands'
+        opt.separator '     create             create a new backup'
+        opt.separator '     help               show this help'
+        opt.separator '     list               list available backups'
+        opt.separator '     restore [time]     restore to a point in time'
+        opt.separator ''
+        opt.separator 'Options'
+
+        opt.on('-c', '--config', '=CONFIG_FILE', 'config file to use instead of ~/.pxcbackup') do |config_file|
+          @options[:config] = config_file
+        end
+
+        opt.on('-d', '--dir', '=BACKUP_DIR', 'local repository to store backups') do |backup_dir|
+          @options[:backup_dir] = backup_dir
+        end
+
+        opt.on('-f', '--full', 'create a full backup') do
+          @options[:type] = :full
+        end
+
+        opt.on('-i', '--incremental', 'create an incremental backup') do
+          @options[:type] = :incremental
+        end
+
+        opt.on('-l', '--local', 'stay local, i.e. do not communicate with S3') do
+          @options[:local] = true
+        end
+
+        opt.on('-r', '--remote', '=REMOTE_URI', 'remote URI to sync backups to, e.g. s3://my-aws-bucket/') do |remote|
+          @options[:remote] = remote
+        end
+
+        opt.on('-v', '--verbose', 'verbose output') do
+          @options[:verbose] = true
+        end
+
+        opt.on('-y', '--yes', 'skip confirmation on backup restore') do
+          @options[:skip_confirmation] = true
+        end
+      end
+
+      begin
+        @command, *@arguments = parser.parse(argv)
+        if @command == 'help'
+          puts parser
+          exit
+        end
+        raise 'no command given' if @command.to_s == ''
+        raise "invalid command #{@command}" unless ['create', 'list', 'restore'].include?(@command)
+      rescue => e
+        abort "#{$0}: #{e.message}\n#{parser}"
+      end
+    end
+  end
+end

data/lib/pxcbackup/array.rb

@@ -0,0 +1,11 @@
+class Array
+  def uniq_by(&blk)
+    transforms = {}
+    select do |el|
+      t = blk[el]
+      should_keep = !transforms[t]
+      transforms[t] = true
+      should_keep
+    end
+  end
+end

data/lib/pxcbackup/backup.rb

@@ -0,0 +1,80 @@
+module PXCBackup
+  class Backup
+    attr_reader :repo, :path
+
+    def initialize(repo, path)
+      @repo = repo
+      @path = path
+      raise 'invalid backup name' unless match
+    end
+
+    def self.regexp
+      /\/(\d+)_(full|incr)\.(xbstream|tar)(\.xbcrypt)?$/
+    end
+
+    def ==(other)
+      @path == other.path && @repo == other.repo
+    end
+
+    def <=>(other)
+      compare = time <=> other.time
+      compare = remote? ? -1 : 1 if compare == 0 && remote? != other.remote?
+      compare
+    end
+
+    def to_s
+      time.to_s
+    end
+
+    def time
+      Time.at(match[:timestamp].to_i)
+    end
+
+    def type
+      type = match[:type]
+      type = 'incremental' if type == 'incr'
+      type.to_sym
+    end
+
+    def stream
+      match[:stream].to_sym
+    end
+
+    def encrypted?
+      match[:encrypted]
+    end
+
+    def full?
+      type == :full
+    end
+
+    def incremental?
+      type == :incremental
+    end
+
+    def remote?
+      @repo.is_a? RemoteRepo
+    end
+
+    def delete
+      @repo.delete(self)
+    end
+
+    def stream_command
+      @repo.stream_command(self)
+    end
+
+    private
+
+    def match
+      match = self.class.regexp.match(@path)
+      return nil unless match
+      {
+        :timestamp => match[1],
+        :type => match[2],
+        :stream => match[3],
+        :encrypted => !!match[4],
+      }
+    end
+  end
+end

data/lib/pxcbackup/backupper.rb

@@ -0,0 +1,409 @@
+require 'fileutils'
+require 'open3'
+require 'tmpdir'
+
+require 'pxcbackup/array'
+require 'pxcbackup/backup'
+require 'pxcbackup/mysql'
+require 'pxcbackup/path_resolver'
+require 'pxcbackup/remote_repo'
+require 'pxcbackup/repo'
+
+module PXCBackup
+  class Backupper
+    def initialize(options)
+      @verbose = options[:verbose] || false
+      @threads = options[:threads] || 1
+      @memory = options[:memory] || '100M'
+      @throttle = options[:throttle] || nil
+      @encrypt = options[:encrypt] || nil
+      @encrypt_key = options[:encrypt_key] || nil
+
+      @which = PathResolver.new(options)
+
+      local_repo_path = options[:backup_dir]
+      @local_repo = local_repo_path ? Repo.new(local_repo_path, options) : nil
+
+      remote_repo_path = options[:remote]
+      @remote_repo = remote_repo_path && !options[:local] ? RemoteRepo.new(remote_repo_path, options) : nil
+
+      @mysql = MySQL.new(options)
+    end
+
+    def make_backup(options = {})
+      type = options[:type] || :full
+      stream = options[:stream] || :xbstream
+      compress = options[:compress] || false
+      compact = options[:compact] || false
+      desync_wait = options[:desync_wait] || 60
+      retention = options[:retention] || 100
+
+      raise 'cannot find backup dir' unless @local_repo && File.directory?(local_repo.path)
+      raise 'cannot enable encryption without encryption key' if @encrypt && !@encrypt_key
+
+      arguments = [
+        @mysql.auth,
+        '--no-timestamp',
+        "--extra-lsndir=#{@local_repo.path}",
+        "--stream=#{stream.to_s}",
+        '--galera-info',
+      ]
+
+      if compress
+        arguments << '--compress'
+      end
+
+      if compact
+        arguments << '--compact'
+      end
+
+      if @encrypt
+        arguments << "--encrypt=#{@encrypt.shellescape}"
+        arguments << "--encrypt-key=#{@encrypt_key.shellescape}"
+      end
+
+      filename = "#{Time.now.to_i}"
+      if type == :incremental
+        last_info = read_backup_info(File.join(@local_repo.path, 'xtrabackup_checkpoints'))
+        arguments << '--incremental'
+        arguments << "--incremental-lsn=#{last_info[:to_lsn]}"
+        filename << "_incr"
+      else
+        filename << '_full'
+      end
+      filename << ".#{stream.to_s}"
+      filename << '.xbcrypt' if @encrypt
+
+      desync_enable(desync_wait)
+
+      Dir.mktmpdir('pxcbackup-') do |dir|
+        arguments << dir.shellescape
+        log_action "Creating backup #{filename}" do
+          innobackupex(arguments, File.join(@local_repo.path, filename))
+        end
+      end
+
+      desync_disable
+      rotate(retention)
+
+      @remote_repo.sync(@local_repo) if @remote_repo
+    end
+
+    def restore_backup(time, skip_confirmation = false)
+      incremental_backups = []
+      all_backups.reverse_each do |backup|
+        incremental_backups.unshift(backup) if backup.time <= time
+        break if incremental_backups.any? && backup.full?
+      end
+      raise "cannot find any backup before #{time}" if incremental_backups.empty?
+      raise "cannot find a full backup before #{time}" unless incremental_backups.first.full?
+      restore_time = incremental_backups.last.time
+
+      full_backup = incremental_backups.shift
+
+      log "[1/#{incremental_backups.size + 1}] Processing #{full_backup.type.to_s} backup from #{full_backup}"
+      with_extracted_backup(full_backup) do |full_backup_path, full_backup_info|
+        raise 'unexpected backup type' unless full_backup_info[:backup_type] == full_backup.type
+        raise 'unexpected start LSN' unless full_backup_info[:from_lsn] == 0
+
+        compact = full_backup_info[:compact]
+
+        if full_backup_info[:compress]
+          log_action '  Decompressing' do
+            innobackupex(['--decompress', full_backup_path.shellescape])
+          end
+        end
+
+	if incremental_backups.any?
+          log_action "  Preparing base backup (LSN #{full_backup_info[:to_lsn]})" do
+            innobackupex(['--apply-log', '--redo-only', full_backup_path.shellescape])
+          end
+
+          current_lsn = full_backup_info[:to_lsn]
+
+          index = 2
+          incremental_backups.each do |incremental_backup|
+            log "[#{index}/#{incremental_backups.size + 1}] Processing #{incremental_backup.type.to_s} backup from #{incremental_backup}"
+            index += 1
+            with_extracted_backup(incremental_backup) do |incremental_backup_path, incremental_backup_info|
+              raise 'unexpected backup type' unless incremental_backup_info[:backup_type] == incremental_backup.type
+              raise 'unexpected start LSN' unless incremental_backup_info[:from_lsn] == current_lsn
+
+              compact ||= incremental_backup_info[:compact]
+
+              if incremental_backup_info[:compress]
+                log_action '  Decompressing' do
+                  innobackupex(['--decompress', incremental_backup_path.shellescape])
+                end
+              end
+
+              log_action "  Applying increment (LSN #{incremental_backup_info[:from_lsn]} -> #{incremental_backup_info[:to_lsn]})" do
+                innobackupex(['--apply-log', '--redo-only', full_backup_path.shellescape, "--incremental-dir=#{incremental_backup_path.shellescape}"])
+              end
+
+              current_lsn = incremental_backup_info[:to_lsn]
+            end
+          end
+        end
+
+        action = 'Final prepare'
+        arguments = [
+          '--apply-log',
+        ]
+
+        if compact
+          action << ' + rebuild indexes'
+          arguments << '--rebuild-indexes'
+        end
+
+        log_action "#{action}" do
+          arguments << full_backup_path.shellescape
+          innobackupex(arguments)
+        end
+
+        log_action 'Attempting to restore Galera info' do
+          restore_galera_info(full_backup_path)
+        end
+
+        mysql_datadir = @mysql.datadir.chomp('/')
+        mysql_datadir_old = mysql_datadir + '_YYYYMMDDhhmmss'
+
+        unless skip_confirmation
+          puts
+          puts '    BACKUP IS NOW READY TO BE RESTORED'
+          puts "    BACKUP TIMESTAMP: #{restore_time}"
+          puts '    PLEASE CONFIRM THIS ACTION'
+          puts
+          puts '    This will:'
+          puts '    - stop the MySQL server'
+          puts "    - move the current datadir to #{mysql_datadir_old}"
+          puts "    - restore the backup to #{mysql_datadir}"
+          puts '    - start the MySQL server'
+          puts
+          puts '    Afterwards you will have to:'
+          puts '    - confirm everything is working and synced correctly'
+          puts '    - manually create a new full backup (to re-allow incremental backups)'
+          puts
+          puts '    If MySQL server cannot be started, this might be because this is the'
+          puts '    only (remaining) Galera node. If so, manually bootstrap the cluster:'
+          puts '    # service mysql bootstrap-pxc'
+          puts
+          print '    Please type "yes" to continue: '
+          confirmation = STDIN.gets.chomp
+          puts
+          raise 'did not confirm restore' unless confirmation == 'yes'
+        end
+
+        log_action 'Stopping MySQL server' do
+          system("#{@which.service.shellescape} mysql stop")
+        end
+
+        stat = File.stat(mysql_datadir)
+        uid = stat.uid
+        gid = stat.gid
+
+        mysql_datadir_old = mysql_datadir + '_' + Time.now.strftime('%Y%m%d%H%M%S')
+        log_action "Moving current datadir to #{mysql_datadir_old}" do
+          File.rename(mysql_datadir, mysql_datadir_old)
+        end
+
+        log_action "Restoring backup to #{mysql_datadir}" do
+          Dir.mkdir(mysql_datadir)
+          innobackupex(['--move-back', full_backup_path.shellescape])
+        end
+
+        log_action "Chowning #{mysql_datadir}" do
+          FileUtils.chown_R(uid, gid, mysql_datadir)
+        end
+
+        if @local_repo
+          log_action "Removing last backup info" do
+            File.delete(File.join(@local_repo.path, 'xtrabackup_checkpoints'))
+          end
+        end
+
+        log_action 'Starting MySQL server' do
+          system("#{@which.service.shellescape} mysql start")
+        end
+      end
+    end
+
+    def list_backups
+      all_backups.each do |backup|
+        if @verbose
+          puts "#{backup} - #{backup.type.to_s[0..3]} (#{backup.remote? ? 'remote' : 'local'})"
+        else
+          puts backup
+        end
+      end
+    end
+
+    private
+
+    def all_backups
+      backups = []
+      backups += @local_repo.backups if @local_repo
+      backups += @remote_repo.backups if @remote_repo
+      backups = backups.uniq_by { |backup| backup.time }
+      backups.sort
+    end
+
+    def log(text)
+      return unless @verbose
+      previous_stdout = $stdout
+      $stdout = STDOUT
+      puts text if @verbose
+      $stdout = previous_stdout
+    end
+
+    def log_action(text)
+      return yield unless @verbose
+
+      begin
+        print "#{text}... "
+        previous_stdout, previous_stderr = $stdout, $stderr
+        begin
+          $stdout = $stderr = File.new('/dev/null', 'w')
+          t1 = Time.now
+          yield
+          t2 = Time.now
+        ensure
+          $stdout, $stderr = previous_stdout, previous_stderr
+        end
+      rescue => e
+        puts "fail"
+        raise e
+      else
+        puts "done (%.1fs)" % (t2 - t1)
+      end
+    end
+
+    def desync_enable(wait = 60)
+      log "Setting wsrep_desync=ON and waiting for #{wait} seconds"
+      @mysql.set_variable('wsrep_desync', 'ON')
+      sleep(wait)
+    end
+
+    def desync_disable
+      log 'Waiting until wsrep_local_recv_queue is empty'
+      sleep(2) until @mysql.get_status('wsrep_local_recv_queue') == '0'
+      log 'Setting wsrep_desync=OFF'
+      @mysql.set_variable('wsrep_desync', 'OFF')
+    end
+
+    def rotate(retention)
+      log 'Checking if we have old backups to remove'
+      @local_repo.backups.each do |backup|
+        days = (Time.now - backup.time) / 86400
+        break if days < retention && backup.full?
+        log "Deleting backup #{backup}"
+        backup.delete
+      end
+    end
+
+    def innobackupex(arguments, output_file = nil)
+      command = @which.innobackupex.shellescape
+      arguments += [
+        "--ibbackup=#{@which.xtrabackup.shellescape}",
+        "--parallel=#{@threads}",
+        "--compress-threads=#{@threads}",
+        "--rebuild-threads #{@threads}",
+        "--use-memory=#{@memory}",
+        "--tmpdir=#{Dir.tmpdir.shellescape}",
+      ]
+      arguments << "--throttle=#{@throttle.shellescape}" if @throttle
+
+      command << ' ' + arguments.join(' ')
+      command << " > #{output_file.shellescape}" if output_file
+      log = Open3.popen3(command) do |stdin, stdout, stderr|
+        stderr.read
+      end
+      exit_status = $?
+      raise 'something went wrong with innobackupex' unless exit_status.success? && log.lines.to_a.last.match(/: completed OK!$/)
+    end
+
+    def read_backup_info(file)
+      raise "cannot open #{file}" unless File.file?(file)
+      result = {}
+      File.open(file, 'r') do |file|
+        file.each_line do |line|
+          key, value = line.chomp.split(/\s*=\s*/, 2)
+          case key
+          when 'backup_type'
+            value = 'full' if value == 'full-backuped'
+            value = value.to_sym
+          when /_lsn$/
+            value = value.to_i
+          when 'compact'
+            value = (value == '1')
+          end
+          result[key.to_sym] = value
+        end
+      end
+      result
+    end
+
+    def with_extracted_backup(backup)
+      Dir.mktmpdir('pxcbackup-') do |dir|
+        command = backup.stream_command
+        action = 'Extracting'
+        if backup.encrypted?
+          raise 'need encryption algorithm and key to decrypt this backup' unless @encrypt && @encrypt_key
+          command << " | #{@which.xbcrypt.shellescape} -d --encrypt-algo=#{@encrypt.shellescape} --encrypt-key=#{@encrypt_key.shellescape}"
+          action << ' + decrypting'
+        end
+        command <<
+          case backup.stream
+          when :xbstream
+            " | #{@which.xbstream.shellescape} -x -C #{dir.shellescape}"
+          when :tar
+            " | #{@which.tar.shellescape} -ixf - -C #{dir.shellescape}"
+          end
+        log_action "  #{action}" do
+          system(command)
+        end
+
+        info = read_backup_info(File.join(dir, 'xtrabackup_checkpoints'))
+        info[:compress] = Dir.glob(File.join(dir, '**', '*.qp')).any?
+
+        yield(dir, info)
+      end
+    end
+
+    def restore_galera_info(dir)
+      galera_info_file = File.join(dir, 'xtrabackup_galera_info')
+      return unless File.file?(galera_info_file)
+      uuid, seqno = nil
+      File.open(galera_info_file, 'r') do |file|
+        uuid, seqno = file.gets.chomp.split(':')
+      end
+
+      version = @mysql.get_status('wsrep_provider_version')
+      if version
+        version = version.split('(').first
+      else
+        current_grastate_file = File.join(@mysql.datadir, 'grastate.dat')
+        if File.file?(current_grastate_file)
+          File.open(current_grastate_file, 'r') do |file|
+            file.each_line do |line|
+              match = line.match(/^version:\s+(.*)$/)
+              if match
+                version = match[1]
+                break
+              end
+            end
+          end
+        end
+      end
+      return unless version
+
+      File.open(File.join(dir, 'grastate.dat'), 'w') do |file|
+        file.write("# GALERA saved state\n")
+        file.write("version: #{version}\n")
+        file.write("uuid:    #{uuid}\n")
+        file.write("seqno:   #{seqno}\n")
+        file.write("cert_index:\n")
+      end
+    end
+  end
+end

data/lib/pxcbackup/mysql.rb

@@ -0,0 +1,50 @@
+require 'shellwords'
+
+module PXCBackup
+  class MySQL
+    attr_reader :datadir
+
+    def initialize(options = {})
+      @which = PathResolver.new(options)
+      @username = options[:mysql_user] || 'root'
+      @password = options[:mysql_pass] || ''
+      @datadir = options[:mysql_datadir] || get_variable('datadir') || '/var/lib/mysql'
+      raise 'Could not find mysql data dir' unless File.directory?(@datadir)
+    end
+
+    def auth
+      "--user=#{@username.shellescape} --password=#{@password.shellescape}"
+    end
+
+    def exec(query)
+      lines = `echo #{query.shellescape} | #{@which.mysql.shellescape} #{auth} 2> /dev/null`.lines.to_a
+      return nil if lines.empty?
+
+      keys = lines.shift.chomp.split("\t")
+      rows = []
+      lines.each do |line|
+        values = line.chomp.split("\t")
+        row = {}
+        keys.each_with_index do |val, key|
+          row[val] = values[key]
+        end
+        rows << row
+      end
+      rows
+    end
+
+    def get_variable(variable, scope = 'GLOBAL')
+      result = exec("SHOW #{scope} VARIABLES LIKE '#{variable}'")
+      result ? result.first['Value'] : nil
+    end
+
+    def set_variable(variable, value, scope = 'GLOBAL')
+      exec("SET #{scope} #{variable}=#{value}")
+    end
+
+    def get_status(variable)
+      result = exec("SHOW STATUS LIKE '#{variable}'")
+      result ? result.first['Value'] : nil
+    end
+  end
+end

data/lib/pxcbackup/path_resolver.rb

@@ -0,0 +1,18 @@
+require 'shellwords'
+
+module PXCBackup
+  class PathResolver
+    def initialize(options = {})
+      @options = options
+      @paths = {}
+    end
+
+    def method_missing(name, *arguments)
+      unless @paths[name]
+        @paths[name] = @options["#{name.to_s}_path".to_sym] || `which #{name.to_s.shellescape}`.strip
+        raise "cannot find path for #{name.to_s}" unless File.file?(@paths[name])
+      end
+      @paths[name]
+    end
+  end
+end

data/lib/pxcbackup/remote_repo.rb

@@ -0,0 +1,39 @@
+require 'shellwords'
+
+require	'pxcbackup/backup'
+require	'pxcbackup/repo'
+
+module PXCBackup
+  class RemoteRepo < Repo
+    def initialize(path, options = {})
+      super(path, options)
+      @which.s3cmd
+    end
+
+    def backups
+      backups = []
+      `#{@which.s3cmd.shellescape} ls #{@path.shellescape}`.lines.to_a.each do |line|
+        path = line.chomp.split[3]
+        next unless Backup.regexp.match(path)
+        backups << Backup.new(self, path)
+      end
+      backups.sort
+    end
+
+    def sync(local_repo)
+      source = File.join(local_repo.path, '/')
+      target = File.join(path, '/')
+      system("#{@which.s3cmd.shellescape} sync --no-progress --delete-removed #{source.shellescape} #{target.shellescape} > /dev/null")
+    end
+
+    def delete(backup)
+      verify(backup)
+      system("#{@which.s3cmd.shellescape} del #{backup.path.shellescape} > /dev/null")
+    end
+
+    def stream_command(backup)
+      verify(backup)
+      "#{@which.s3cmd.shellescape} get #{backup.path.shellescape} -"
+    end
+  end
+end

data/lib/pxcbackup/repo.rb

@@ -0,0 +1,42 @@
+require 'shellwords'
+
+require 'pxcbackup/backup'
+
+module PXCBackup
+  class Repo
+    attr_reader :path
+
+    def initialize(path, options = {})
+      @path = path
+      @which = PathResolver.new(options)
+    end
+
+    def backups
+      backups = []
+      Dir.foreach(@path) do |file|
+        path = File.join(@path, file)
+        next unless File.file?(path)
+        next unless Backup.regexp.match(path)
+        backups << Backup.new(self, path)
+      end
+      backups.sort
+    end
+
+    def delete(backup)
+      verify(backup)
+      system("#{@which.rm.shellescape} #{backup.path.shellescape}")
+    end
+
+    def stream_command(backup)
+      verify(backup)
+      "#{@which.cat.shellescape} #{backup.path.shellescape}"
+    end
+
+    private
+
+    def verify(backup)
+      raise 'backup does not belong to this repo' if backup.repo != self
+    end
+  end
+end
+

data/lib/pxcbackup/version.rb

@@ -0,0 +1,3 @@
+module PXCBackup
+  VERSION = "0.0.1"
+end

data/lib/pxcbackup.rb

@@ -0,0 +1,2 @@
+require 'pxcbackup/version'
+require 'pxcbackup/backupper'

data/pxcbackup.gemspec

@@ -0,0 +1,18 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pxcbackup/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'pxcbackup'
+  spec.version     = PXCBackup::VERSION
+  spec.author      = 'Robbert Klarenbeek'
+  spec.email       = 'robbertkl@renbeek.nl'
+  spec.summary     = 'Backup tool for Percona XtraDB Cluster'
+  spec.description = spec.summary
+  spec.homepage    = 'https://github.com/robbertkl/pxcbackup'
+  spec.license     = 'MIT'
+
+  spec.files       = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: pxcbackup
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Robbert Klarenbeek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-08 00:00:00.000000000 Z
+dependencies: []
+description: Backup tool for Percona XtraDB Cluster
+email: robbertkl@renbeek.nl
+executables:
+- pxcbackup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- LICENSE
+- README.md
+- bin/pxcbackup
+- lib/pxcbackup.rb
+- lib/pxcbackup/application.rb
+- lib/pxcbackup/array.rb
+- lib/pxcbackup/backup.rb
+- lib/pxcbackup/backupper.rb
+- lib/pxcbackup/mysql.rb
+- lib/pxcbackup/path_resolver.rb
+- lib/pxcbackup/remote_repo.rb
+- lib/pxcbackup/repo.rb
+- lib/pxcbackup/version.rb
+- pxcbackup.gemspec
+homepage: https://github.com/robbertkl/pxcbackup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Backup tool for Percona XtraDB Cluster
+test_files: []