rbarman 0.0.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Holger Amann <holger@sauspiel.de>
+
+MIT License
+
+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,125 @@
+# rbarman
+
+rbarman - Ruby Wrapper for 2ndQuadrant's PostgreSQL backup tool [pgbarman](http://pgbarman.org)
+
+## Installation
+
+pgbarman has to be installed and configured on the same host where this gem is to be used, otherwise it cannot get any useful information about your backups ;)
+
+
+Add this line to your application's Gemfile:
+
+    gem 'rbarman'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rbarman
+
+## Usage
+
+### Get all your backups!
+
+This will call pgbarman and some other sources (backup.info, xlog.db) to get information about your backups. This could take several minutes (and  memory) if you have many backups with thousand of wal files. If you don't want to scan for wal file information, use RBarman::Backups.all('server', false)
+
+<pre>
+backups = RBarman::Backups.all('server', true)
+backups.count
+=> 3
+
+backups.each { |b| p "id: #{b.id} }
+=> "id: 20130304T080002"
+=> "id: 20130225T192654"
+=> "id: 20130218T080002"
+
+backups.latest.id
+=> "20130304T080002"
+
+backups.oldest.id
+=> "20130218T080002"
+
+backups[0].status
+=> :done    # :started, :failed, :empty
+
+backups[0].backup_start.to_s
+=> "2013-03-04 08:00:02 +0100"
+
+backups[0].backup_end.to_s
+=> "2013-03-04 16:46:28 +0100"
+
+backups[0].size
+=> 201071500850 # bytes
+
+backups[0].wal_file_size
+=> 41875931136  # bytes
+
+backups[0].timeline
+=> 1
+
+backups[0].begin_wal.xlog
+=> "0000058F"
+
+backups[0].end_wal.segment
+=> "000000A5"
+
+backups[0].wal_files.count
+=> 9019
+
+backups[0].wal_files[1022].compression
+=> :bzip2
+</pre>
+
+### Get just one backup without wal files
+
+<pre>
+backup = RBarman::Backup.by_id('server', '20130225T192654', false)
+p "id: #{backup.id}|size: #{backup.size / (1024 ** 3) } GB|wal size: #{backup.wal_file_size / (1024 ** 3)} GB"
+=> "id: 20130225T192654|size: 217GB|wal size: 72 GB"
+</pre>
+
+### Create a backup
+
+Creates a new backup (and probably takes some time)
+
+<pre>
+b = RBarman::Backup.create('server')
+p b.id
+=> "20130304T131422"
+</pre>
+
+### Delete a backup
+
+This tells pgbarman to delete the specified backup
+
+<pre>
+backup = RBarman::Backup.by_id('server', '20130225T192654', false)
+p backup.deleted
+=> false
+backup.delete
+p backup.deleted
+=> true
+</pre>
+
+### Not yet implemented
+
+* restore backups
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Meta
+
+Written by [Holger Amann](http://github.com/hamann), sponsored by [Sauspiel GmbH](https://www.sauspiel.de)
+
+Release under the MIT License: http://www.opensource.org/licenses/mit-license.php
+

data/lib/rbarman/backup.rb

@@ -0,0 +1,106 @@
+require 'time'
+
+module RBarman
+
+  class InvalidBackupIdError < RuntimeError
+  end
+
+  class Backup
+    attr_accessor :server 
+    attr_reader :id, :backup_start, :backup_end, :status, :wal_files, :size, :wal_file_size, :begin_wal, :end_wal, :timeline, :pgdata, :deleted
+
+    def initialize
+      @deleted = false
+    end
+
+    def id=(id)
+      raise InvalidBackupIdError if !Backup.backup_id_valid?(id)
+      @id = id 
+    end
+
+    def backup_start=(start)
+      @backup_start = Time.parse(start)
+    end
+
+    def backup_end=(b_end)
+      @backup_end = Time.parse(b_end)
+    end
+
+    def status=(status)
+      if status != :empty and
+        status != :started and
+        status != :done and
+        status != :failed
+        raise(ArgumentError,"only :empty, :started, :done or :failed allowed!")
+      end
+
+      @status = status
+    end
+
+    def wal_files=(wal_files)
+      raise(ArgumentError, "argument not of type array") if !wal_files.is_a? Array
+      @wal_files = wal_files
+    end
+
+    def size=(size)
+      @size = size.to_i
+    end
+
+    def begin_wal=(wal_file)
+      @begin_wal = WalFile.parse(wal_file)
+    end
+
+    def end_wal=(wal_file)
+      @end_wal = WalFile.parse(wal_file)
+    end
+
+
+    def wal_file_size=(size)
+      @wal_file_size = size.to_i
+    end
+
+    def timeline=(i)
+      raise(ArgumentError, "timeline should be > 0") if i.to_i == 0
+      @timeline = i.to_i
+    end
+
+    def pgdata=(path)
+      raise(ArgumentError, "path is empty") if path == ""
+      @pgdata = path
+    end
+
+    def add_wal_file(wal_file)
+      @wal_files = Array.new if @wal_files.nil?
+      @wal_files << WalFile.parse(wal_file)
+    end
+
+    def wal_file_already_added?(wal_file)
+      return false if @wal_files.nil?
+      return @wal_files.include?(WalFile.parse(wal_file))
+    end
+
+
+    def self.backup_id_valid?(id)
+      return false if id.nil?
+      return !id.match(/\d{8,8}T\d{6,6}/).nil?
+    end
+
+    def delete
+      cmd = CliCommand.new
+      cmd.delete(@server, @id)
+      @deleted = true
+    end
+
+    def self.create(server)
+      cmd = CliCommand.new
+      cmd.create(server)
+      backups = Backups.all(server, false)
+      return Backup.by_id(server, backups.latest.id, true)
+    end
+
+    def self.by_id(server, backup_id, with_wal_files=true)
+      cmd = CliCommand.new
+      return cmd.backup(server, backup_id, with_wal_files)
+    end
+  end
+end

data/lib/rbarman/backups.rb

@@ -0,0 +1,20 @@
+module RBarman
+  class Backups < Array
+    def initialize(other=nil)
+      self.concat(other) if !other.nil? and other.is_a? Array
+    end
+
+    def self.all(server, with_wal_files=true)
+      cmd = CliCommand.new
+      return Backups.new(cmd.backups(server, with_wal_files))
+    end
+
+    def latest
+      self.sort_by { |d| Time.parse(d.id) }.reverse.first
+    end
+
+    def oldest
+      self.sort_by { |d| Time.parse(d.id) }.first
+    end
+  end
+end

data/lib/rbarman/cli_command.rb

@@ -0,0 +1,163 @@
+require 'mixlib/shellout'
+
+module RBarman
+  class CliCommand
+    attr_reader :binary, :barman_home
+
+    def initialize(path_to_binary=nil, path_to_barman_home=nil)
+      self.binary=path_to_binary || Configuration.instance.binary
+      self.barman_home=path_to_barman_home || Configuration.instance.barman_home
+    end
+
+    def binary=(path)
+      raise(ArgumentError, "binary doesn't exist") if !File.exists?(path)
+      raise(ArgumentError, "binary isn't called \'barman\'") if File.basename(path) != 'barman'
+      @binary = path
+    end
+
+    def barman_home=(path)
+      raise(ArgumentError, "path doesn't exist") if !File.exists?(path)
+      @barman_home = path
+    end
+
+    def backup(server, backup_id, with_wal_files=true)
+      raise(ArgumentError, "backup id must not be nil!") if backup_id.nil?
+      return backups(server, with_wal_files, backup_id)[0]
+    end
+
+    def backups(server, with_wal_files=true, backup_id=nil)
+      list = run_barman_command("list-backup #{server}")
+      list = list.grep(/#{backup_id}/) if !backup_id.nil?
+
+      backups = parse_backup_list(list)
+      backups.each do |backup|
+        parse_backup_info_file(backup)
+        if with_wal_files
+          wals = wal_files(backup.server, backup.id)
+          wals.each { |w| backup.add_wal_file(w) }
+        end
+      end
+      return backups
+    end
+
+    def wal_files(server, backup_id)
+      lines = run_barman_command("list-files --target wal #{server} #{backup_id}")
+      wal_files = parse_wal_files_list(lines)
+      xlog_db_lines = file_content("#{@barman_home}/#{server}/wals/xlog.db")
+      wal_files.each do |w| 
+        wal = "#{w.timeline}#{w.xlog}#{w.segment}"
+        lines = xlog_db_lines.grep(/^#{wal}\t.+/)
+        raise(RuntimeError, "Found more than one wal file entry in xlog.db for #{wal}") if lines.count > 1
+        raise(RuntimeError, "Could not find any entry for #{wal} in xlog.db") if lines.count == 0
+        wal_file_info_from_xlog_db_line(w, lines[0])
+      end
+      return wal_files
+    end
+
+    def parse_wal_files_list(lines)
+      wal_files = Array.new
+      lines.each do |line|
+        wal_files << WalFile.parse(line.split("/").last)
+      end
+      return wal_files
+    end
+
+    def parse_backup_list(lines)
+      result = Array.new
+      lines.each do |l|
+        match = l.match(/^(.+)\s(\d+T\d+)/)
+        b = Backup.new
+        b.server = match[1]
+        b.id = match[2]
+
+        status_match = l.match(/.+(FAILED|STARTED)/)
+        status_match.nil? ? b.status = :done : b.status = status_match[1].downcase.to_sym
+        
+        if b.status == :done
+          sizematch = l.match(/.+Size:\s(.+)\s(.+)\s-.+Size:\s(.+)\s(.+)/)
+          b.size = size_in_bytes(sizematch[1].to_f, sizematch[2])
+          b.wal_file_size = size_in_bytes(sizematch[3].to_f, sizematch[4])
+        end
+        result << b
+      end
+      return result
+    end
+
+    def parse_backup_info_file(backup)
+      raise(ArgumentError, "arg not of type Backup") if !backup.is_a? Backup
+      raise(ArgumentError, "Backup.id not set") if backup.id.nil?
+      raise(ArgumentError, "Backup.server not set") if backup.server.nil?
+      backup_info = file_content("#{barman_home}/#{backup.server}/base/#{backup.id}/backup.info")
+      backup_info.each do |l|
+        key, value = l.split("=")
+        case key
+        when "begin_time"
+          backup.backup_start = value
+        when "end_time"
+          backup.backup_end = value
+        when "status"
+          backup.status = value.downcase.to_sym
+        when "size"
+          backup.size = value.to_i
+        when "timeline"
+          backup.timeline = value.to_i
+        when "begin_wal"
+          backup.begin_wal = WalFile.parse(value)
+        when "end_wal"
+          backup.end_wal = WalFile.parse(value)
+        when "pgdata"
+          backup.pgdata = value
+        end
+      end
+    end
+
+    def wal_file_info_from_xlog_db_line(wal_file, line)
+      splitted = line.split("\t")
+      wal_file.size = splitted[1]
+      wal_file.created = splitted[2].to_i
+      wal_file.compression = splitted[3].downcase.to_sym
+    end
+
+    def size_in_bytes(size, identifier)
+      raise(ArgumentError, "identifier not one of B|KiB|MiB|GiB|TiB") if !identifier.match(/(B|KiB|MiB|GiB|TiB)/)
+      size_b = 0
+      case identifier
+      when "B"
+        size_b = size
+      when "KiB"
+        size_b = size * 1024
+      when "MiB"
+        size_b = size * 1024 ** 2
+      when "GiB"
+        size_b = size * 1024 ** 3
+      when "TiB"
+        size_b = size * 1024 ** 4 
+      end
+      return size_b.to_i
+    end
+
+    def delete(server, backup_id)
+      run_barman_command("delete #{server} #{backup_id}")
+    end
+
+    def create(server)
+      run_barman_command("backup #{server}")
+    end
+
+    private
+    def run_barman_command(args)
+      sh = Mixlib::ShellOut.new("#{@binary} #{args}")
+
+      # TODO timeout should be configurable
+      sh.timeout = 43200 # 12h
+
+      sh.run_command
+      sh.error!
+      return sh.stdout.split("\n")
+    end
+
+    def file_content(path)
+      return File.readlines(path).map { |l| l.chomp }
+    end
+  end
+end

data/lib/rbarman/configuration.rb

@@ -0,0 +1,46 @@
+require 'singleton'
+
+module RBarman
+  class Configuration
+    include Singleton 
+
+    def initialize(data={})
+      @data = {}
+      update!(data)
+      basic_configuration
+    end
+
+    def update!(data)
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def [](key)
+      @data[key.to_sym]
+    end
+
+    def []=(key, value)
+      if value.class == Hash
+        @data[key.to_sym] = Config.new(value)
+      else
+        @data[key.to_sym] = value
+      end
+    end
+
+    def method_missing(sym, *args)
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        self[sym]
+      end
+    end
+
+    def basic_configuration
+      b_path = `which barman`.chomp
+      self[:binary] = b_path.empty? ? '/usr/bin/barman' : b_path
+      self[:barman_home] = ENV['HOME']
+    end
+
+  end
+end

data/lib/rbarman/version.rb

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

data/lib/rbarman/wal_file.rb

@@ -0,0 +1,82 @@
+require 'time'
+
+module RBarman
+
+  class InvalidWalFileNameError < RuntimeError
+  end
+
+  class WalFile
+
+    attr_reader :timeline, :xlog, :segment, :created, :compression, :size
+
+    def initialize
+    end
+
+    def timeline=(timeline)
+      validate(timeline)
+      @timeline = timeline
+    end
+
+    def xlog=(xlog)
+      validate(xlog)
+      @xlog = xlog
+    end
+
+    def segment=(segment)
+      validate(segment)
+      @segment = segment
+    end
+
+    def compression=(compression)
+      if compression != :gzip and
+        compression != :bzip2 and
+        compression != :none and
+        compression != :custom
+        raise(ArgumentError, "only :gzip, :bzip2, :none or :custom allowed!")
+      end
+
+      @compression = compression
+    end
+
+    def size=(size)
+      @size = size.to_i
+    end
+
+    def created=(created)
+      @created = created if created.is_a? Time
+      @created = Time.at(created.to_i) if created.is_a? Numeric
+      @created = Time.parse(created) if created.is_a? String
+    end
+
+    def self.parse(name)
+      raise(InvalidWalFileNameError, "name has to be exactly 24 chars") if !name.is_a? WalFile and name.to_s.size != 24 
+
+      if name.is_a? WalFile
+        wal_file = name
+      else
+        splitted = name.to_s.scan(/.{8}/)
+        raise InvalidWalFileNameError if splitted.count != 3
+
+        wal_file = WalFile.new
+        wal_file.timeline = splitted[0]
+        wal_file.xlog = splitted[1]
+        wal_file.segment = splitted[2]
+      end
+
+      return wal_file
+    end
+
+    def ==(other)
+      o = other
+      o = WalFile.parse(other.to_s) if !other.is_a? WalFile
+      return o.timeline == @timeline && o.xlog == @xlog && o.segment == @segment
+    end
+
+    private
+
+    def validate(arg)
+      raise(ArgumentError, "arg's size must be 8") if arg.to_s.size != 8
+    end
+  end
+end
+

data/lib/rbarman.rb

@@ -0,0 +1,9 @@
+require "rbarman/version"
+require "rbarman/backup"
+require "rbarman/backups"
+require "rbarman/wal_file"
+require "rbarman/cli_command"
+require "rbarman/configuration"
+
+module RBarman
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rbarman
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Holger Amann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: mixlib-shellout
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: Wrapper about 2ndQuadrant's postgresql backup tool \'barman\'
+email:
+- holger@sauspiel.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rbarman/backup.rb
+- lib/rbarman/backups.rb
+- lib/rbarman/cli_command.rb
+- lib/rbarman/configuration.rb
+- lib/rbarman/version.rb
+- lib/rbarman/wal_file.rb
+- lib/rbarman.rb
+- LICENSE.txt
+- README.md
+homepage: https://github.com/sauspiel/rbarman
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Wrapper about 2ndQuadrant's postgresql backup tool \'barman\'
+test_files: []