ebs-snapshoter 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2009-04-12
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,84 @@
+snapshoter
+    by Kris Rasmussen
+    http://www.dreamthis.com
+
+== DESCRIPTION:
+
+Provides EBS snapshot automation that can be configured and run on an EC2 instance.
+
+Snapshot Process:
+
+* Read configuration
+* Fetch snapshot descriptions from ec2
+* For each volume in configuration
+* - If it is time to run a new snapshot based on the most recent snapshot date
+* -- freeze mysql (if using mysql)
+* -- freeze xfs
+* -- create the snapshot
+* -- unfreeze xfs
+* -- unfreeze mysql
+* -- delete old snapshots
+
+== FEATURES/PROBLEMS:
+
+You can configure the following options:
+
+* EBS volumes to backup
+* Backup frequency: currently only daily or weekly
+* Number of backups to keep (up to ec2 limits)
+* Mysql database freezing
+
+== SYNOPSIS:
+
+  /etc/snapshoter.yml
+    
+    aws_public_key: VSdfslkfjsdf...
+    aws_private_key: df23knlkvjsdf...
+
+    vol-VVVV1113:
+      mount_point: /data1
+      frequency: daily
+      freeze_mysql: true
+      mysql_user: root
+      mysql_password: XDFDSE32
+      keep: 20
+
+    vol-BBBBB1112:
+      mount_point: /data2
+      frequency: weekly
+  
+== REQUIREMENTS:
+
+* EBS volumes using XFS as filesystem
+
+== INSTALL:
+
+* sudo gem install snapshoter
+* Configure /etc/snapshoter.yml
+* create the following cron entry: 0 1 * * * /usr/bin/snapshoter
+* OR: call the snapshoter script directly after some other work processing every day
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Kris Rasmussen
+
+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/Rakefile

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "ebs-snapshoter"
+    s.executables = "snapshoter"
+    s.summary = "Provides EBS snapshot automation that can be configured and run on an EC2 instance."
+    s.email = "kristopher.rasmussen@gmail.com"
+    s.homepage = "http://github.com/krisr/ebs-snapshoter"
+    s.description = "Provides EBS snapshot automation that can be configured and run on an EC2 instance."
+    s.authors = ["Kris Rasmussen"]
+    s.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+    s.add_dependency 'right_aws'
+    s.add_dependency 'mysql'
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'lib/snapshoter'
+
+task :default => 'spec:run'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "foo #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+# EOF

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/snapshoter

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib snapshoter]))
+
+require 'optparse'
+
+# Options
+# -------
+
+config_file = '/etc/snapshoter.yml'
+verbose     = false
+
+# Option Parsing
+# --------------
+
+opts = OptionParser.new { |opts|
+  opts.banner = "Usage: snapshoter [options]"
+  
+  opts.separator ""
+  opts.separator "Specific options:"
+  
+  opts.on("-c", "--config FILE",
+          "The configuration to use (default #{config_file})") do |file|
+    config_file = file
+  end
+  
+  opts.on("-v", "--verbose", "Run with verbose logging") do
+    verbose = true
+  end
+  
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    puts Snapshoter.version
+    exit
+  end
+}.parse!(ARGV)
+
+# Run
+# ---
+
+config   = Snapshoter::Config.read(config_file)
+provider = Snapshoter::Provider::EC2Provider.new(config)
+manager  = Snapshoter::Manager.new(config, provider)
+manager.run

data/lib/snapshoter/config.rb

@@ -0,0 +1,60 @@
+require 'yaml'
+require 'logger'
+
+module Snapshoter
+  class ConfigError < Exception
+  end
+  
+  class Config
+    attr_reader :aws_public_key, :aws_private_key, :volumes
+    
+    def initialize(config)
+      @aws_public_key = config.delete('aws_public_key')
+      @aws_private_key = config.delete('aws_private_key')
+      @log_file  = config.delete('log_file')
+      @log_level = config.delete('log_level')
+      
+      @volumes = []
+      
+      config.keys.each do |volume_id|
+        volume_options = config[volume_id]
+        if volume_options.is_a? Hash
+          begin
+            @volumes << Snapshoter::Volume.new(volume_id, config[volume_id])
+          rescue Snapshoter::VolumeInvalid => e
+            raise ConfigError.new(e.message)
+          end
+          config.delete(volume_id)
+        end
+      end
+      
+      if config.any?
+        raise ConfigError.new("Invalid config option(s) #{config.keys.map{|k| "'#{k}'"}.join(',')}")
+      end
+    end
+    
+    def logger
+      @logger ||= begin
+        logger = Logger.new(@log_file || STDOUT)
+        logger.level = case @log_level
+          when 'warn'
+            Logger::WARN
+          when 'error'
+            Logger::ERROR
+          when 'FATAL'
+            Logger::FATAL
+          when 'debug'
+            Logger::DEBUG
+          else
+            Logger::INFO
+          end
+        logger
+      end
+    end
+    
+    def Config.read(path='/etc/snapshoter.yml')
+      config = YAML.load(File.read(path))
+      Config.new(config)
+    end
+  end
+end

data/lib/snapshoter/manager.rb

@@ -0,0 +1,134 @@
+require 'mysql'
+
+module Snapshoter
+  class Manager
+    def initialize(config, provider)
+      @config = config
+      @provider = provider
+    end
+    
+    def run
+      # ensure we have the latest snapshot data
+      @provider.refresh
+      
+      # First create all the snapshots
+      @config.volumes.each do |volume|
+        if should_take_snapshot(volume)
+          if volume.freeze_mysql
+            mysql = Mysql.connect(
+                    'localhost',
+                    volume.mysql_user, 
+                    volume.mysql_password,
+                    volume.mysql_port,
+                    volume.mysql_sock)
+          else
+            mysql = nil
+          end
+        
+          logger.debug "[Volume #{volume}] Starting snapshot"
+          success = false
+          begin
+            lock_mysql(mysql) if mysql
+            freeze_xfs(volume.mount_point)
+            @provider.snapshot_volume(volume)
+          rescue Exception => e
+            logger.error "[Volume #{volume}] There was a problem creating snapshot!"
+            logger.error e.message
+            logger.error e.backtrace.join("\n")
+          ensure
+            unfreeze_xfs(volume.mount_point)
+            if mysql
+              unlock_mysql(mysql)
+              mysql.close
+            end
+          end
+        end
+      end
+      
+      # ensure we have the latest snapshot data
+      @provider.refresh
+      
+      # Then cleanup old snapshots
+      @config.volumes.each do |volume|
+        delete_old_snapshots(volume)
+      end
+    end
+    
+  private
+  
+    def logger
+      @config.logger
+    end
+    
+    def freeze_xfs(mount_point)
+      logger.debug "Freezing filesystem at #{mount_point}"
+      `xfs_freeze -f #{mount_point}`
+      logger.debug "Filesystem frozen at #{mount_point}"
+    end
+    
+    def unfreeze_xfs(mount_point)
+      logger.debug "unfreezing xfs on mount point #{mount_point}"
+      `xfs_freeze -u #{mount_point}`
+    end
+  
+    def lock_mysql(mysql)
+      logger.debug "locking mysql tables"
+      mysql.query "FLUSH TABLES WITH READ LOCK"
+      # TODO: capture mysql master bin log position and log it somewhere
+    end
+    
+    def unlock_mysql(mysql)
+      logger.debug  "unfreezing mysql"
+      mysql.query   "UNLOCK TABLES"
+    end
+    
+    def delete_old_snapshots(volume)
+      logger.debug "Deleting old snapshots of volume #{volume}"
+      begin
+        n = @provider.delete_old_snapshots(volume)
+        logger.info "[Volume #{volume}] Deleted #{n} old snapshots" if n > 0
+      rescue Exception => e
+        logger.error "[Volume #{volume}] There was a problem deleting old snaphots"
+        logger.error e.message
+        logger.error e.backtrace.join("\n")
+      end
+    end
+    
+    def should_take_snapshot(volume)
+      if last_snapshot_at = @provider.last_snapshot_at(volume)
+        
+        last = last_snapshot_at.localtime
+        now  = Time.now
+        
+        if volume.frequency == :hourly
+          time_of_last_snapshot = seconds_to_hours(last)
+          current_time          = seconds_to_hours(now)
+        elsif volume.frequency == :daily
+          time_of_last_snapshot = seconds_to_days(last)
+          current_time          = seconds_to_days(now)
+        elsif volume.frequency == :weekly
+          time_of_last_snapshot = seconds_to_weeks(last)
+          current_time          = seconds_to_weeks(now)
+        else
+          raise "Unknown frequency #{volume.frequency}"
+        end
+        
+        time_of_last_snapshot != current_time
+      else
+        true
+      end
+    end
+    
+    def seconds_to_hours(s)
+      s.strftime("%Y%m%d%H")
+    end
+    
+    def seconds_to_days(s)
+      s.strftime("%Y%m%d")
+    end
+    
+    def seconds_to_weeks(s)
+      s.strftime("%Y%m") + ((s.day - 1) / 7).to_s
+    end
+  end
+end

data/lib/snapshoter/provider/ec2.rb

@@ -0,0 +1,76 @@
+require 'right_aws'
+
+module Snapshoter
+  module Provider
+    class EC2Provider
+      def initialize(config)
+        @config = config
+      end
+    
+      # Returns the most recent time a snapshot was started for a given volume or nil if there are none
+      def last_snapshot_at(volume)
+        snapshots = snapshots_by_volume_id(volume.id)
+        snapshots.any? ? snapshots.first[:aws_started_at] : nil
+      end
+    
+      def snapshot_volume(volume)
+        logger.info "[Volume #{volume.id}] Snapshot started"
+        if ec2.create_snapshot(volume.id)
+          logger.info "[Volume #{volume.id}] Snapshot complete"
+        else
+          logger.error "[Volume #{volume.id}] Snapshot failed!"
+        end
+      end
+    
+      def delete_old_snapshots(volume)
+        deleted_count = 0
+        old_snapshots = snapshots_by_volume_id(volume.id)[volume.keep..-1]
+        if old_snapshots && old_snapshots.any?
+          logger.info "[Volume #{volume.id}] Deleting #{old_snapshots.length} old snapshots for #{volume.id}"
+          old_snapshots.each do |snapshot|
+            if snapshot[:aws_status] == 'completed'
+              logger.debug "[Volume #{volume.id}][Snapshot #{snapshot[:aws_id]}] Deleting snapshot created on #{snapshot[:aws_started_at]} #{snapshot[:aws_id]}"
+              if ec2.delete_snapshot(snapshot[:aws_id])
+                deleted_count += 1
+                logger.debug "[Volume #{volume.id}][Snapshot #{snapshot[:aws_id]}] Snapshot deleted"
+              else
+                logger.error "[Volume #{volume.id}][Snapshot #{snapshot.id}] Snapshot delete failed!"
+              end
+            else
+              logger.info "[Volume #{volume.id}][Snapshot #{snapshot.id}] Could not be deleted because status is '#{snapshot[:aws_status]}'"
+            end
+          end
+        else
+          logger.debug "[Volume #{volume.id}] No old snapshots to delete"
+        end
+        deleted_count
+      end
+    
+      def refresh
+        snapshots(true) if @snapshots
+      end
+      
+    private
+  
+      def logger
+        @config.logger
+      end
+  
+      def snapshots_by_volume_id(volume_id)
+        snapshots.select {|s| s[:aws_volume_id] == volume_id}.sort_by{|s| s[:aws_started_at]}.reverse
+      end
+  
+      def snapshots(refresh=false)
+        if @snapshots && !refresh
+          @snapshots
+        else
+          @snapshots = ec2.describe_snapshots
+        end
+      end
+    
+      def ec2
+        @ec2 ||= RightAws::Ec2.new(@config.aws_public_key, @config.aws_private_key)
+      end
+    end
+  end
+end

data/lib/snapshoter/volume.rb

@@ -0,0 +1,61 @@
+module Snapshoter
+  class VolumeInvalid < Exception
+    def initialize(id, errors)
+      @id = id
+      @errors = errors
+    end
+
+    def message
+      "Error with configuration of volume #{@id || '<unknown>'}:\n  #{@errors.join("\n  ")}\n"
+    end
+  end
+  
+  class Volume
+    ValidFrequencies = [:hourly, :daily, :weekly]
+    
+    attr_reader :id, :mount_point, :frequency, :freeze_mysql, :mysql_user, :mysql_password, :mysql_port, :mysql_sock, :keep
+    
+    def initialize(volume_id, options={})
+      options = options.symbolize_keys
+      
+      @id = volume_id
+      @mount_point = options.delete(:mount_point)
+      @frequency = options.delete(:frequency) || 'daily'
+      @freeze_mysql = options.delete(:freeze_mysql) || false
+      @mysql_user = options.delete(:mysql_user) || 'root'
+      @mysql_password = options.delete(:mysql_password)
+      @mysql_port = options.delete(:mysql_port) 
+      @mysql_sock = options.delete(:mysql_sock) 
+      @keep = options.delete(:keep) || 7
+      
+      @frequency = @frequency.to_sym
+      
+      validate!(options)
+    end
+    
+    def to_s
+      "##{@id}"
+    end
+    
+  private
+  
+    def validate!(extra_options)
+      errors = []
+      
+      errors << 'volume must have an id' if @id.nil?
+      errors << "frequency must be one of #{ValidFrequencies.join(",")}" unless ValidFrequencies.include?(@frequency)
+      errors << 'mount_point must be specified' if @mount_point.nil?
+      errors << 'freeze_mysql must be true or false' if @freeze_mysql != true && @freeze_mysql != false
+      errors << "keep must be greater than 0" if keep <= 0
+      
+      extra_options.keys.each do |key|
+        errors << "unknown volume attribute #{key}"
+      end
+            
+      if errors.any?
+        raise VolumeInvalid.new(@id, errors)
+      end
+    end
+    
+  end
+end

data/lib/snapshoter.rb

@@ -0,0 +1,70 @@
+
+module Snapshoter
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module Snapshoter
+
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  
+  def except!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+    keys.each { |key| delete(key) }
+    self
+  end
+  
+  def except(*keys)
+    dup.except!(*keys)
+  end
+end
+
+
+
+
+Snapshoter.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/spec/snapshoter_spec.rb

@@ -0,0 +1,67 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Snapshoter do
+  
+end
+
+describe Snapshoter::Volume do
+  before do
+    @valid_attributes = {
+      'mount_point' => '/data',
+    }
+  end
+  
+  it "should initialize successfully with valid attributes" do
+    Snapshoter::Volume.new('vol-test', @valid_attributes)
+  end
+  
+  it "should raise a Snapshoter::VolumeInvalid when initialized without an id" do
+    lambda {
+      Snapshoter::Volume.new(nil, @valid_attributes)
+    }.should raise_error Snapshoter::VolumeInvalid, /volume must have an id/
+  end
+  
+  it "should raise a Snapshoter::VolumeInvalid when the frequency is anything but hourly, daily or weekly" do
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:frequency => 'hourly'))
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:frequency => 'daily'))
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:frequency => 'weekly'))
+    
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:frequency => 'yearly'))
+    }.should raise_error Snapshoter::VolumeInvalid, /frequency must be one of/
+  end
+  
+  it "should raise a Snapshoter::VolumeInvalid when freeze_mysql is anything but true or false" do
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:freeze_mysql => true))
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:freeze_mysql => false))
+    
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:freeze_mysql => 33))
+    }.should raise_error Snapshoter::VolumeInvalid, /freeze_mysql must be/
+  end
+  
+  it "should raise a Snapshoter::VolumeInvalid when keep is less than or equal to 0" do
+    Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:keep => 33))
+    
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:keep => 0))
+    }.should raise_error Snapshoter::VolumeInvalid, /keep must/
+    
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:keep => -2))
+    }.should raise_error Snapshoter::VolumeInvalid, /keep must/
+  end
+  
+  it "should raise a a Snapshoter::VolumeInvalid when initialized with an unknown option" do
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge(:keep2 => 0))
+    }.should raise_error Snapshoter::VolumeInvalid, /unknown/
+    
+    lambda {
+      Snapshoter::Volume.new('vol-test', @valid_attributes.merge('apple' => 0))
+    }.should raise_error Snapshoter::VolumeInvalid, /unknown/
+  end
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib snapshoter]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: ebs-snapshoter
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kris Rasmussen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-10 00:00:00 -07:00
+default_executable: snapshoter
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Provides EBS snapshot automation that can be configured and run on an EC2 instance.
+email: kristopher.rasmussen@gmail.com
+executables: 
+- snapshoter
+extensions: []
+
+extra_rdoc_files: 
+- README.txt
+files: 
+- History.txt
+- README.txt
+- Rakefile
+- VERSION
+- bin/snapshoter
+- lib/snapshoter.rb
+- lib/snapshoter/config.rb
+- lib/snapshoter/manager.rb
+- lib/snapshoter/provider/ec2.rb
+- lib/snapshoter/volume.rb
+- test/test_snapshoter.rb
+has_rdoc: true
+homepage: http://github.com/krisr/ebs-snapshoter
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Provides EBS snapshot automation that can be configured and run on an EC2 instance.
+test_files: 
+- spec/snapshoter_spec.rb
+- spec/spec_helper.rb
+- test/test_snapshoter.rb