s3-tar-backup 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 842cea517d3276df06766424c4354d644069df99
+  data.tar.gz: 1ad93ccb5dd87a00b794692643cdf9dfc4936bcd
+SHA512:
+  metadata.gz: bc7a8b17a71626eef16fc974d4725a2cb11482d4cdb51201093c3a51e1fe12565228666a2302f5d1498f298b8579ceb23c2e913a75682961e5425f00e842ca84
+  data.tar.gz: f7b8d94f5f23c8f234c2f1003b6a48132baacba2df14db0b9754b45cdea812f783e20ffee995b20595864fbf8141280ffd6d65160b33ef097abc1d5ed3966d02

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+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,250 @@
+S3-tar-backup
+=============
+
+About
+-----
+
+This tool allows you to backup a set of directories to an Amazon S3 bucket, using incremental backups.
+You can then restore the files at a later date.
+
+This tool was built as a replacement for duplicity, after duplicity started throwing errors and generally being a bit unreliable.
+It uses command-line tar to create incremental backup snapshots, and the aws-s3 gem to upload these to S3.
+
+In practice, it turns out that this tool has few lower bandwidth and CPU requirements, and can restore a backup in a fraction of the time that duplicity would take.
+
+Installation
+------------
+
+This tool is not yet a ruby gem, and unless people ask me, it will remain that way.
+
+Therefore, to install:
+
+```
+$ git clone git://github.com/canton7/s3-tar-backup.git
+$ cd s3-tar-backup
+$ sudo rake install
+```
+
+Configuration
+-------------
+
+### Introduction
+
+Configuration is done using an ini file, which can be in the location of your choice.
+
+The config file consists of two sections: a global `[settings]` section, followed by profiles.
+With the exception of two keys, every configuration key can be specified either in `[settings]`, in a profile, or both (in which case the profile value is either replaces, or is added to, the value from `[settings]`).
+
+### Global config
+
+```ini
+[settings]
+; These two keys must be located in this section
+; You can use environmental variables instead of these -- see below
+aws_access_key_id = <your aws access key>
+aws_secret_access_key = <your aws secret key>
+
+; Set this to the AWS region you want to use
+; See http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region
+aws_region = <your aws region>
+
+; The rest of the keys can either be located here, or in your profiles, or both
+; The value from the profile will replace the value specified here
+full_if_older_than = <timespec>
+
+; Choose one of the following two settings
+remove_older_than = <timespec>
+remove_all_but_n_full = <number>
+
+backup_dir = </path/to/dir>
+dest = <bucket_name>/<path>
+pre-backup = <some command>
+post-backup = <some command>
+
+compression = <compression_type>
+
+always_full = <bool>
+
+; You have have multiple lines of the following types.
+; Values from here and from your profiles will be combined
+source = </path/to/another/source>
+source = </path/to/another/source>
+exclude = </some/dir>
+exclude = </some/other/dir>
+
+```
+
+`aws_access_key_id` and `aws_secret_access_key` are fairly obvious -- you'll have been given these when you signed up for S3.
+If you can't find them, [look here](http://aws.amazon.com/security-credentials).
+You can use the environmental variables AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY instead if you prefer -- the env vars will override the config options.
+
+`full_if_older_than` tells s3-tar-backup how long if should leave between full backups.  
+`<timespec>` is stolen from duplicity. It is given as an interval, which is a number followed by one of the characers s, m, h, D, W, M, or Y (indicating seconds, minutes, hours, days, weeks, months, or years respectively), or a series of such pairs.
+For instance, "1h45m" indicates the time that was one hour and 45 minutes ago.
+The calendar here is unsophisticated: a month is always 30 days, a year is always 365 days, and a day is always 86400 seconds.
+
+`remove_older_than` tells s3-tar-backup to remove old backups which are older than `<timespec>` (see above for the format of `<timespec>`).
+
+`remove_all_but_n_full` tells s3-tar-backup to remove all backups which were made before the last `n` full backups.
+
+`backup_dir` is the directory used (a) to store temporary data, and (b) to store a record of what files were backed up last time (tar's snar file).
+You can delete this dir at any time, but that will slow down the next backup slightly.
+
+`dest` is the place where your backups are stored. It consists of the name of the S3 bucket (buckets aren't created automatically), followed by the folder to store objects in, for example `my-backups/tar/`.
+
+`pre-backup` and `post-backup` are two hooks, which are run before and after a backup, respectively.
+These lines are optional -- you can have no pre-backup or post-backup lines anywhere in your config if you wish.
+Note that `post-backup` is only run after a successful command.
+These can be used to do things such as back up a mysql database.
+Note that you can have multiple `pre-backup` and `post-backup` lines -- all of the listed commands will be executed.
+
+`compression` gives the compression type.
+Valid values are `gzip`, `bzip2`, `lzma`, `lzma2`.
+s3-tar-backup is capable of auto-detecting the format of a previously-backed-up archive, and so changing this value will not invalidate previous backups.
+
+`always_full` is an optional key which have have the value `True` or `False`.
+This is used to say that incremental backups should never be used.
+
+`source` contains the folders to be backed up.
+
+`exclude` lines specify files/dirs to exclude from the backup.
+See the `--exclude` option to tar.
+The exclude lines are optional -- you can have no exclude lines anywhere in your config if you wish.
+
+**Note:** You can have multiple profiles which use the same `dest` and `backup_dir`.
+
+### Profile config
+
+Next, define your profiles.
+
+Profiles are used to specify, or override from the global config, those config keys which may be specified in either the global config or in a profile.
+
+A profile takes the form:
+
+```ini
+[profile "profile_name"]
+; You can optionally specify the following keys
+backup_dir = </path/to/dir>
+source = </path/to/source>
+source = </path/to/another/source>
+dest = <bucket_name>/<path>
+exclude = </some/dir>
+pre-backup = <some command>
+post-backup = <some command>
+```
+
+`profile_name` is the name of the profile. You'll use this later.
+
+### Example config file
+
+```ini
+[settings]
+aws_access_key = ABCD
+aws_secret_access_key = ABCDE
+aws_region = eu-west-1
+; Do a new full backup every 2 weeks
+full_if_older_than = 2W
+; Keep 5 sets of full backups
+remove_all_but_n_full = 5
+backup_dir = /root/.backup
+dest = my-backups/tar
+; You may prefer bzip2, as it has a much lower CPU cost
+compression = lzma2
+
+[profile "www"]
+source = /srv/http
+
+[profile "home"]
+source = /home/me
+source = /root
+exclude = .backup
+; Do full backups less rarely
+full_if_older_than = 4W
+
+[profile "mysql"]
+pre-backup = mysqldump -uuser -ppassword --all-databases > /tmp/mysql_dump.sql
+source = /tmp/mysql_dump.sql
+post-backup = rm /tmp/mysql_dump.sql
+; My MySQL dumps are so small that incremental backups actually add more overhead
+always_full = True
+```
+
+Usage
+-----
+
+s3-tar-backup works in a number of different modes: backup, restore, cleanup, backup-config, list-backups.
+
+### Backup
+
+```
+s3-tar-backup --config <config_file> [--profile <profile>] --backup [--full] [--verbose]
+```
+
+You can use `-c` instead of `--config`, and `-p` instead of `--profile`.
+
+`<config_file>` is the path to the file you created above, and `<profile>` is the name of a profile inside it.
+You can also specify multiple profiles.
+
+If no profile is specified, all profiles are backed up.
+
+`--full` will force s3-tar-backup to do a full backup (instead of an incremental one), regardless of which it thinks it should do based on your cofnig file.
+
+`--verbose` will get tar to list the files that it is backing up.
+
+Example:
+
+```
+s3-tar-backup -c ~/.backup/config.ini -p www home --backup
+```
+
+### Cleanup
+
+**Note:** Cleans are automatically done at the end of each backup.
+
+```
+s3-tar-backup --config <config_file> [--profile <profile>] --cleanup
+```
+
+s3-tar-backup will go through all old backups, and remove those specified by `remove_all_but_n_full` or `remove_older_than`.
+
+### Restore
+
+```
+s3-tar-backup --config <config_file> [--profile <profile>] --restore <restore_dir> [--restore_date <restore_date>] [--verbose]
+```
+
+This command will get s3-tar-backup to fetch all the necessary data to restore the latest version of your backup (or an older one if you use `--restore-date`), and stick it into `<restore_dir>`.
+
+Using `<restore_date>`, you can tell s3-tar-backup to restore the first backup before the specified date.
+The date format to use is `YYYYMM[DD[hh[mm[ss]]]]`, for example `20110406` means `2011-04-06 00:00:00`, while `201104062143` means `2011-04-06 21:43:00`.
+
+`--verbose` makes tar spit out the files that it restores.
+
+Examples:
+
+```
+s3-tar-backup -c ~/.backup/config.ini -p www home --restore my_restore/
+s3-tar-backup -c ~/.backup/config.ini -p mysql --restore my_restore/ --restore_date 201104062143
+```
+
+### Backup Config file
+
+```
+s3-tar-backup --config <config_file> [--profile <profile>] --backup-config [--verbose]
+```
+
+This command is used to backup the specified configuration file.
+Where it is backed up to depends on your setup: 
+
+ - If you've specified `dest` under `[settings]`, this location is used
+ - If you're only got one profile, and `dest` is under this profile, then this location is used.
+ - If you have multiple profiles, and there's no `dest` under `[settings]`, you must specify a profile, and this profile's `dest` will be used.
+ 
+### List backups
+
+```
+s3-tar-backup --config <config_file> [--profile <profile>] --list-backups [--verbose]
+```
+
+This command is used to view information on the current backed-up archives for the specified profile(s) (or all profiles).
+This is handy if you need to restore a backup, and want to know things such as how much data you'll have to download, or what dates are available to restore from.

data/bin/s3-tar-backup

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname($PROGRAM_NAME)+File::SEPARATOR+'..'+File::SEPARATOR+'lib')
+
+require 's3_tar_backup'
+
+S3TarBackup::Main.new.run

data/lib/s3_tar_backup.rb

@@ -0,0 +1,312 @@
+require 'aws-sdk'
+require 'trollop'
+require 's3_tar_backup/ini_parser'
+require 's3_tar_backup/backup'
+require 's3_tar_backup/version'
+
+module S3TarBackup
+	class Main
+		UPLOAD_TRIES = 5
+
+		def run
+			opts = Trollop::options do
+				version VERSION
+				banner "Backs up files to, and restores files from, Amazon's S3 storage, using tar incremental backups\n\n" \
+					"Usage:\ns3-tar-backup -c config.ini [-p profile] --backup [--full] [-v]\n" \
+					"s3-tar-backup -c config.ini [-p profile] --cleanup [-v]\n" \
+					"s3-tar-backup -c config.ini [-p profile] --restore restore_dir\n\t[--restore_date date] [-v]\n" \
+					"s3-tar-backup -c config.ini [-p profile] --backup-config [--verbose]\n" \
+					"s3-tar-backup -c config.ini [-p profile] --list-backups\n\n" \
+					"Option details:\n"
+				opt :config, "Configuration file", :short => 'c', :type => :string, :required => true
+				opt :backup, "Make an incremental backup"
+				opt :full, "Make the backup a full backup"
+				opt :profile, "The backup profile(s) to use (default all)", :short => 'p', :type => :strings
+				opt :cleanup, "Clean up old backups"
+				opt :restore, "Restore a backup to the specified dir", :type => :string
+				opt :restore_date, "Restore a backup from the specified date. Format YYYYMM[DD[hh[mm[ss]]]]", :type => :string
+				opt :backup_config, "Backs up the specified configuration file"
+				opt :list_backups, "List the stored backup info for one or more profiles"
+				opt :verbose, "Show verbose output", :short => 'v'
+				conflicts :backup, :cleanup, :restore, :backup_config, :list_backups
+			end
+
+
+			Trollop::die "--full requires --backup" if opts[:full] && !opts[:backup]
+			Trollop::die "--restore-date requires --restore" if opts[:restore_date_given] && !opts[:restore_given]
+			unless opts[:backup] || opts[:cleanup] || opts[:restore_given] || opts[:backup_config] || opts[:list_backups]
+				Trollop::die "Need one of --backup, --cleanup, --restore, --backup-config, --list-backups"
+			end
+
+			begin
+				raise "Config file #{opts[:config]} not found" unless File.exists?(opts[:config])
+				config = IniParser.new(opts[:config]).load
+				profiles = opts[:profile] || config.find_sections(/^profile\./).keys.map{ |k| k.to_s.split('.', 2)[1] }
+				@s3 = connect_s3(
+					ENV['AWS_ACCESS_KEY_ID'] || config['settings.aws_access_key_id'],
+					ENV['AWS_SECRET_ACCESS_KEY'] || config['settings.aws_secret_access_key'],
+					config.get('settings.aws_region', false)
+				)
+
+				# This is a bit of a special case
+				if opts[:backup_config]
+					dest = config.get('settings.dest', false)
+					raise "You must specify a single profile (used to determine the location to back up to) " \
+						"if backing up config and dest key is not in [settings]" if !dest && profiles.count != 1
+					dest ||= config["profile.#{profiles[0]}.dest"]
+					puts "===== Backing up config file #{opts[:config]} ====="
+					bucket, prefix = (config.get('settings.dest', false) || config["profile.#{profiles[0]}.dest"]).split('/', 2)
+					puts "Uploading #{opts[:config]} to #{bucket}/#{prefix}/#{File.basename(opts[:config])}"
+					upload(opts[:config], bucket, "#{prefix}/#{File.basename(opts[:config])}")
+					return
+				end
+
+				profiles.dup.each do |profile|
+					raise "No such profile: #{profile}" unless config.has_section?("profile.#{profile}")
+					opts[:profile] = profile
+					backup_config = gen_backup_config(opts[:profile], config)
+					prev_backups = get_objects(backup_config[:bucket], backup_config[:dest_prefix], opts[:profile])
+					perform_backup(opts, prev_backups, backup_config) if opts[:backup]
+					perform_cleanup(prev_backups, backup_config) if opts[:backup] || opts[:cleanup]
+					perform_restore(opts, prev_backups, backup_config) if opts[:restore_given]
+					perform_list_backups(prev_backups, backup_config) if opts[:list_backups]
+				end
+			rescue Exception => e
+				raise e
+				Trollop::die e.to_s
+			end
+		end
+
+		def connect_s3(access_key, secret_key, region)
+			warn "No AWS region specified (config key settings.s3_region). Assuming eu-west-1" unless region
+			AWS::S3.new(access_key_id: access_key, secret_access_key: secret_key, region: region || 'eu-west-1')
+		end
+
+		def gen_backup_config(profile, config)
+			bucket, dest_prefix = (config.get("profile.#{profile}.dest", false) || config['settings.dest']).split('/', 2)
+			backup_config = {
+				:backup_dir => config.get("profile.#{profile}.backup_dir", false) || config['settings.backup_dir'],
+				:name => profile,
+				:sources => [*config.get("profile.#{profile}.source", [])] + [*config.get("settings.source", [])],
+				:exclude => [*config.get("profile.#{profile}.exclude", [])] + [*config.get("settings.exclude", [])],
+				:bucket => bucket,
+				:dest_prefix => dest_prefix.chomp('/'),
+				:pre_backup => [*config.get("profile.#{profile}.pre-backup", [])] + [*config.get('settings.pre-backup', [])],
+				:post_backup => [*config.get("profile.#{profile}.post-backup", [])] + [*config.get('settings.post-backup', [])],
+				:full_if_older_than => config.get("profile.#{profile}.full_if_older_than", false) || config['settings.full_if_older_than'],
+				:remove_older_than => config.get("profile.#{profile}.remove_older_than", false) || config.get('settings.remove_older_than', false),
+				:remove_all_but_n_full => config.get("profile.#{profile}.remove_all_but_n_full", false) || config.get('settings.remove_all_but_n_full', false),
+				:compression => (config.get("profile.#{profile}.compression", false) || config.get('settings.compression', 'gzip')).to_sym,
+				:always_full => config.get('settings.always_full', false) || config.get("profile.#{profile}.always_full", false),
+			}
+			backup_config
+		end
+
+		def perform_backup(opts, prev_backups, backup_config)
+			puts "===== Backing up profile #{backup_config[:name]} ====="
+			backup_config[:pre_backup].each_with_index do |cmd, i|
+				puts "Executing pre-backup hook #{i+1}"
+				system(cmd)
+			end
+			full_required = full_required?(backup_config[:full_if_older_than], prev_backups)
+			puts "Last full backup is too old. Forcing a full backup" if full_required && !opts[:full] && backup_config[:always_full]
+			if full_required || opts[:full] || backup_config[:always_full]
+				backup_full(backup_config, opts[:verbose])
+			else
+				backup_incr(backup_config, opts[:verbose])
+			end
+			backup_config[:post_backup].each_with_index do |cmd, i|
+				puts "Executing post-backup hook #{i+1}"
+				system(cmd)
+			end
+		end
+
+		def perform_cleanup(prev_backups, backup_config)
+			puts "===== Cleaning up profile #{backup_config[:name]} ====="
+			remove = []
+			if age_str = backup_config[:remove_older_than]
+				age = parse_interval(age_str)
+				remove = prev_backups.select{ |o| o[:date] < age }
+				# Don't want to delete anything before the last full backup
+				unless remove.empty?
+					kept = remove.slice!(remove.rindex{ |o| o[:type] == :full }..-1).count
+					puts "Keeping #{kept} old backups as part of a chain" if kept > 1
+				end
+			elsif keep_n = backup_config[:remove_all_but_n_full]
+				keep_n = keep_n.to_i
+				# Get the date of the last full backup to keep
+				if last_full_to_keep = prev_backups.select{ |o| o[:type] == :full }[-keep_n]
+					# If there is a last full one...
+					remove = prev_backups.select{ |o| o[:date] < last_full_to_keep[:date] }
+				end
+			end
+
+			if remove.empty?
+				puts "Nothing to do"
+			else
+				puts "Removing #{remove.count} old backup files"
+			end
+			remove.each do |object|
+				@s3.buckets[backup_config[:bucket]].objects["#{backup_config[:dest_prefix]}/#{object[:name]}"].delete
+			end
+		end
+
+		# Config should have the keys
+		# backup_dir, name, soruces, exclude, bucket, dest_prefix
+		def backup_incr(config, verbose=false)
+			puts "Starting new incremental backup"
+			backup = Backup.new(config[:backup_dir], config[:name], config[:sources], config[:exclude], config[:compression])
+
+			# Try and get hold of the snar file
+			unless backup.snar_exists?
+				puts "Failed to find snar file. Attempting to download..."
+				s3_snar = "#{config[:dest_prefix]}/#{backup.snar}"
+				object = @s3.buckets[config[:bucket]].objects[s3_snar]
+				if object.exists?
+					puts "Found file on S3. Downloading"
+					open(backup.snar_path, 'wb') do |f|
+						object.read do |chunk|
+							f.write(chunk)
+						end
+					end
+				else
+					puts "Failed to download snar file. Defaulting to full backup"
+				end
+			end
+
+			backup(config, backup, verbose)
+		end
+
+		def backup_full(config, verbose=false)
+			puts "Starting new full backup"
+			backup = Backup.new(config[:backup_dir], config[:name], config[:sources], config[:exclude], config[:compression])
+			# Nuke the snar file -- forces a full backup
+			File.delete(backup.snar_path) if File.exists?(backup.snar_path)
+			backup(config, backup, verbose)
+		end
+
+		def backup(config, backup, verbose=false)
+			system(backup.backup_cmd(verbose))
+			puts "Uploading #{config[:bucket]}/#{config[:dest_prefix]}/#{File.basename(backup.archive)} (#{bytes_to_human(File.size(backup.archive))})"
+			upload(backup.archive, config[:bucket], "#{config[:dest_prefix]}/#{File.basename(backup.archive)}")
+			puts "Uploading snar (#{bytes_to_human(File.size(backup.snar_path))})"
+			upload(backup.snar_path, config[:bucket], "#{config[:dest_prefix]}/#{File.basename(backup.snar)}")
+			File.delete(backup.archive)
+		end
+
+		def upload(source, bucket, dest_name)
+			tries = 0
+			begin
+				@s3.buckets[bucket].objects.create(dest_name, Pathname.new(source))
+			rescue Errno::ECONNRESET => e
+				tries += 1
+				if tries <= UPLOAD_TRIES
+					puts "Upload Exception: #{e}"
+					puts "Retrying #{tries}/#{UPLOAD_TRIES}..."
+					retry
+				else
+					raise e
+				end
+			end
+			puts "Succeeded" if tries > 0
+		end
+
+		def perform_restore(opts, prev_backups, backup_config)
+			puts "===== Restoring profile #{backup_config[:name]} ====="
+			# If restore date given, parse
+			if opts[:restore_date_given]
+				m = opts[:restore_date].match(/(\d\d\d\d)(\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?/)
+				raise "Unknown date format in --restore-to" if m.nil?
+				restore_to = Time.new(*m[1..-1].map{ |s| s.to_i if s })
+			else
+				restore_to = Time.now
+			end
+
+			# Find the index of the first backup, incremental or full, before that date
+			restore_end_index = prev_backups.rindex{ |o| o[:date] < restore_to }
+			raise "Failed to find a backup for that date" unless restore_end_index
+
+			# Find the first full backup before that one
+			restore_start_index = prev_backups[0..restore_end_index].rindex{ |o| o[:type] == :full }
+
+			restore_dir = opts[:restore].chomp('/') << '/'
+
+			Dir.mkdir(restore_dir) unless Dir.exists?(restore_dir)
+			raise "Detination dir is not a directory" unless File.directory?(restore_dir)
+
+			prev_backups[restore_start_index..restore_end_index].each do |object|
+				puts "Fetching #{backup_config[:bucket]}/#{backup_config[:dest_prefix]}/#{object[:name]} (#{bytes_to_human(object[:size])})"
+				dl_file = "#{backup_config[:backup_dir]}/#{object[:name]}"
+				open(dl_file, 'wb') do |f|
+					@s3.buckets[backup_config[:bucket]].objects["#{backup_config[:dest_prefix]}/#{object[:name]}"].read do |chunk|
+						f.write(chunk)
+					end
+				end
+				puts "Extracting..."
+				system(Backup.restore_cmd(restore_dir, dl_file, opts[:verbose]))
+
+				File.delete(dl_file)
+			end
+		end
+
+		def perform_list_backups(prev_backups, backup_config)
+			# prev_backups alreays contains just the files for the current profile
+			puts "===== Backups list for #{backup_config[:name]} ====="
+			puts "Type: N:  Date:#{' '*18}Size:       Chain Size:   Format:\n\n"
+			prev_type = ''
+			total_size = 0
+			chain_length = 0
+			chain_cum_size = 0
+			prev_backups.each do |object|
+				type = object[:type] == prev_type && object[:type] == :incr ? " -- " : object[:type].to_s.capitalize
+				prev_type = object[:type]
+				chain_length += 1
+				chain_length = 0 if object[:type] == :full
+				chain_cum_size = 0 if object[:type] == :full
+				chain_cum_size += object[:size]
+
+				chain_length_str = (chain_length == 0 ? '' : chain_length.to_s).ljust(3)
+				chain_cum_size_str = (object[:type] == :full ? '' : bytes_to_human(chain_cum_size)).ljust(8)
+				puts "#{type}  #{chain_length_str} #{object[:date].strftime('%F %T')}    #{bytes_to_human(object[:size]).ljust(8)}    " \
+					"#{chain_cum_size_str}      (#{object[:compression]})"
+				total_size += object[:size]
+			end
+			puts "\n"
+			puts "Total size: #{bytes_to_human(total_size)}"
+			puts "\n"
+		end
+
+		def get_objects(bucket, prefix, profile)
+			objects = @s3.buckets[bucket].objects.with_prefix(prefix).map do |object|
+				Backup.parse_object(object, profile)
+			end
+			objects.compact.sort_by{ |o| o[:date] }
+		end
+
+		def parse_interval(interval_str)
+			time = Time.now
+			time -= $1.to_i if interval_str =~ /(\d+)s/
+			time -= $1.to_i*60 if interval_str =~ /(\d+)m/
+			time -= $1.to_i*3600 if interval_str =~ /(\d+)h/
+			time -= $1.to_i*86400 if interval_str =~ /(\d+)D/
+			time -= $1.to_i*604800 if interval_str =~ /(\d+)W/
+			time -= $1.to_i*2592000 if interval_str =~ /(\d+)M/
+			time -= $1.to_i*31536000 if interval_str =~ /(\d+)Y/
+			time
+		end
+
+		def full_required?(interval_str, objects)
+			time = parse_interval(interval_str)
+			objects.select{ |o| o[:type] == :full && o[:date] > time }.empty?
+		end
+
+		def bytes_to_human(n)
+			count = 0
+			while n >= 1014 && count < 4
+				n /= 1024.0
+				count += 1
+			end
+			format("%.2f", n) << %w(B KB MB GB TB)[count]
+		end
+	end
+end