ec2-snapshot 0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Voormedia B.V.
+
+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,122 @@
+EC2-snapshot - create snapshots from all mounted EBS volumes
+============================================================
+
+EC2-snapshot is gem that allows you to easily create snapshots for mounted EBS volumes on
+an EC2 instance.
+
+The idea originated from the wish of automating snapshot creation for EC2 instances and making
+it easy to integrate it into Chef.
+
+EC2-snapshot was written with the idea of it running only on the EC2 instance for which snapshots
+need to be created. Because we wanted to use it with Chef, we needed to keep configuration to a minimum.
+There is no need to provide an instance id or volume ids, as that will already be retrieved on the 
+instance itself. The only necessities are the AWS credentials, region and an option to set which types
+of volumes need to be snapshotted.
+
+Therefore, the current implementation doesn't support the case of using a snapshotting server that creates snapshots 
+for all volumes. It is meant to run on all servers that require snapshots to be created of its volumes.
+
+
+Features
+--------
+
+* No need to specify instance id and volume ids while using the gem
+* Recognizes XFS filesystems, and looks up mount points automatically
+* Freezes XFS filesystems while creating the snapshot, resulting in a consistent snapshot
+* Easy integration within Chef, requiring a very simple recipe that only requires (globally defined) AWS credentials and a region
+* Easy integration within your own scripts with either the executable or by instantiating the `Ec2Snapshot::Instance` class yourself
+* Custom actions that need to be executed before and/or after the snapshot is created can be easily configured
+
+
+Requirements
+------------
+
+There are some requirements for using this gem:
+
+* The gem only works on Linux, as it has dependencies on files such as `/etc/hostname` and `/proc/mounts`
+* `wget` needs to be installed. This is required to automatically retrieve the current instance id
+* `xfs_freeze` (included in xfsprogs package) needs to be installed in order to be able to freeze a XFS filesystem to get a consistent snapshot
+
+
+Getting started
+---------------
+
+Installing the Gem is pretty straightforward:
+
+	gem install ec2-snapshot
+
+Note that `/etc/hostname` is used to get the name of the current instance.
+Also `/proc/mounts` is used to retrieve information on the filesystems to be snapshotted.
+
+
+Using the executable
+--------------------
+
+An executable has been provided to easily use the gem within your own scripts.
+
+The executable requires a few mandatory details to be able to use your AWS account. These are:
+
+* `AWS Access Key`: The access key defaults to `ENV["AWS_ACCESS_KEY_ID"]`. 
+If the environment variable is not set the value should be provided as an option while using the executable, 
+ie. `--aws-access-key KEY`
+* `AWS Secret Access Key`: The secret access key defaults to `ENV["AWS_SECRET_ACCESS_KEY"]`.
+If the environment variable is not set the value should be provided as an option while using the executable, 
+ie. `--aws-secret-access-key KEY`
+* `AWS Region`: The region on which the volumes have been created. Needs to be provided as an option, 
+ie. `--aws-region eu-west-1`
+
+The gem makes a distinction between root volumes and data volumes. The root volume is the volume on which the OS 
+is installed, while the data volumes are other volumes mounted on the same instance that could for example be used to store 
+application specific data.
+
+By default, EC2-snapshot will attempt to create snapshots of all volumes mounted on the 
+current instance. In case you only need snapshots of the data volumes, which could be a valid case when using Chef, 
+you can easily specify that by using the `--volume-type` option:
+
+	ec2-snapshot --aws-access-key ACCESS_KEY --aws-secret-access-key KEY --aws-region us-west-1 --volume-type data
+
+For a complete list of supported options, please execute
+	
+	ec2-snapshot -h
+
+Take note that `xfs_freeze` requires the process to run with root privileges (sudo), otherwise the XFS filesystem 
+cannot be frozen.
+
+
+Security
+--------
+
+The most secure way of using EC2-snapshot is to create a new user with AWS IAM and allow that user to only execute a 
+specific set of actions.
+
+The following actions are required:
+
+* ec2:CreateSnapshot
+* ec2:CreateTags
+* ec2:DeleteSnapshot
+* ec2:DescribeInstances
+* ec2:DescribeSnapshots
+
+By restricting the user to only these actions, you can make sure that the access keys required for EC2-instance cannot 
+be misused to manipulate the instances themselves.
+
+
+Inspiration
+-----------
+
+EC2-snapshot was inspired by [ec2-consistent-snapshot](https://launchpad.net/ec2-consistent-snapshot) and 
+its Ruby port [ec2-consistent-snapshot-rb](http://rubygems.org/gems/ec2-consistent-snapshot-rb).
+
+
+About EC2-snapshot
+------------------
+
+EC2-snapshot was created by Mattijs van Druenen (m.vandruenen *at* voormedia.com)
+
+Copyright 2011 Voormedia - [www.voormedia.com](http://www.voormedia.com/)
+
+
+License
+-------
+
+EC2-snapshot is released under the MIT license.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+Rake::TestTask.new
+task :default => :test

data/bin/ec2-snapshot

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require "ec2_snapshot"
+require "optparse"
+require "date"
+
+options = Hash.new
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: ec2-snapshot [options]"
+
+  options[:volume_type] = :all
+  opts.on("--volume-type TYPE", [:all, :root, :data], "Volume types that need to be snapshotted (all/root/data). Defaults to all.") do |volume_type|
+    options[:volume_type] = volume_type
+  end
+
+  options[:aws_access_key] = ENV["AWS_ACCESS_KEY_ID"]
+  opts.on("--aws-access-key KEY", "AWS Access Key.Either set ENV[\"AWS_ACCESS_KEY_ID\"] or provide it as an option.") do |access_key|
+    options[:aws_access_key] = access_key
+  end
+
+  options[:aws_secret_access_key] = ENV["AWS_SECRET_ACCESS_KEY"]
+  opts.on("--aws-secret-access-key KEY", "AWS Secret Access Key. Either set ENV[\"AWS_SECRET_ACCESS_KEY\"] or provide it as an option.") do |secret_access_key|
+    options[:aws_secret_access_key] = secret_access_key
+  end
+
+  opts.on("--aws-region REGION", "AWS Region. Mandatory. Example regions are eu-west-1 and us-west-1") do |region|
+    options[:aws_region] = region
+  end
+
+  opts.on("--before BEFORE", "Shell command to run before volume is snapshotted. Optional.") do |before|
+    options[:before] = before
+  end
+
+  opts.on("--after AFTER", "Shell command to run after volume is snapshotted. Optional.") do |after|
+    options[:after] = after
+  end
+
+  opts.on("--delete-older-than MONTHS", "Delete snapshots for this instance that are older than # months. Optional.") do |months|
+    options[:delete_older_than] = months.to_i
+  end
+
+  options[:verbose] = false
+  opts.on("-v", "--verbose", "Display progress output.") do |verbose|
+    options[:verbose] = verbose
+  end
+
+  opts.on("-h", "--help", "Display this screen.") do
+    puts opts
+    exit
+  end
+end
+
+optparse.parse!
+
+if options[:aws_access_key].nil? or options[:aws_secret_access_key].nil? or options[:aws_region].nil?
+  Kernel.abort("Not all mandatory options have been provided. Exiting.")
+end
+
+instance = Ec2Snapshot::Instance.new(options)
+instance.enable_rootvol_snapshot if [:all, :root].include?(options[:volume_type])
+instance.enable_datavol_snapshot if [:all, :data].include?(options[:volume_type])
+instance.create_snapshots
+instance.delete_snapshots(Date.today << options[:delete_older_than]) if options.include?(:delete_older_than)

data/ec2-snapshot.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/ec2_snapshot/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "ec2-snapshot"
+  gem.authors       = ["mattijsvandruenen"]
+  gem.email         = ["m.vandruenen@voormedia.com"]
+  gem.description   = %q{EC2 EBS Volume Snapshotting}
+  gem.summary       = %q{Create consistent snapshots of EBS volumes on Amazon EC2 instances.}
+  gem.homepage      = "https://github.com/voormedia/ec2-snapshot"
+
+  gem.add_runtime_dependency "right_aws"
+  gem.add_development_dependency "minitest", "~> 2.8.0"
+  gem.add_development_dependency "mocha"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.version       = Ec2Snapshot::VERSION
+end

data/lib/ec2-snapshot.rb

@@ -0,0 +1 @@
+require 'ec2_snapshot'

data/lib/ec2_snapshot.rb

@@ -0,0 +1,2 @@
+require 'ec2_snapshot/instance'
+require 'ec2_snapshot/volume'

data/lib/ec2_snapshot/instance.rb

@@ -0,0 +1,88 @@
+require "date"
+require "right_aws"
+
+module Ec2Snapshot
+  class Instance
+    attr_accessor :ec2, :ec2_info, :create_rootvol_snapshot, :create_datavol_snapshot, :before, :after, :verbose
+
+    def initialize(options = {})
+      @ec2 = RightAws::Ec2.new(options[:aws_access_key], options[:aws_secret_access_key], :region => options[:aws_region], :logger => Logger.new('/dev/null'))
+      @ec2_info = @ec2.describe_instances(instance_id).first
+      @create_rootvol_snapshot = false
+      @create_datavol_snapshot = false
+      @before = options[:before]
+      @after = options[:after]
+      @verbose = options[:verbose] ? options[:verbose] : false
+    end
+
+    def enable_rootvol_snapshot
+      @create_rootvol_snapshot = true
+    end
+
+    def enable_datavol_snapshot
+      @create_datavol_snapshot = true
+    end
+
+    def create_snapshots
+      volumes.each do |volume|
+        next if not volume.requires_snapshot
+        
+        puts "preparing snapshot for volume #{volume.volume_id} (#{volume.device_name})" if @verbose
+        custom_actions do
+          volume.freeze_filesystem do
+            volume.create_snapshot
+          end
+        end
+      end
+    end
+
+    def delete_snapshots(cut_off_date = Date.today << 3)
+      # This function requires a tag called Hostname to be set for each snapshot of the current instance
+      @ec2.describe_snapshots(:filters => {'tag:Hostname' => hostname}).each do |snapshot|
+        if Date.parse(snapshot[:aws_started_at]) <= cut_off_date
+          puts "deleting snapshot #{snapshot[:aws_id]}" if @verbose
+          @ec2.delete_snapshot(snapshot[:aws_id])
+        end
+      end
+    end
+
+    def custom_actions(&block)
+      if @before
+        puts "executing before command" if @verbose
+        Kernel.system(@before)
+      end
+      begin
+        yield
+      rescue Exception => ex
+        puts "exception thrown during snapshot creation: #{ex}" if @verbose
+      ensure
+        if @after
+          puts "executing after command" if @verbose
+          Kernel.system(@after)
+        end
+      end
+    end
+
+    def instance_id
+      # See http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/index.html?AESDG-chapter-instancedata.html
+      output = %x[wget -T 5 -t 1 -q -O - http://169.254.169.254/latest/meta-data/instance-id]
+      raise if output.empty?
+      output
+    rescue
+      # catch both empty output and missing wget
+      raise "Failed to retrieve the current instance id"
+    end
+
+    def hostname
+      %x[cat /etc/hostname].chomp
+    end
+
+    def root_device_name
+      @ec2_info[:root_device_name]
+    end
+
+    def volumes
+      @ec2_info[:block_device_mappings].collect{ |v| Ec2Snapshot::Volume.new(self, v[:ebs_volume_id], v[:device_name]) }
+    end
+  end
+end

data/lib/ec2_snapshot/version.rb

@@ -0,0 +1,3 @@
+module Ec2Snapshot
+  VERSION = "0.1"
+end

data/lib/ec2_snapshot/volume.rb

@@ -0,0 +1,63 @@
+module Ec2Snapshot
+  class Volume
+    attr_accessor :instance, :volume_id, :device_name, :mount_point, :file_system
+
+    def initialize(instance, volume_id, device_name)
+      @instance = instance
+      @volume_id = volume_id
+      @device_name = device_name
+      init_mount_info
+    end
+
+    def requires_snapshot
+      root_device = @instance.root_device_name
+      raise Exception, "No root device could be found" unless root_device
+      (root_device == @device_name and @instance.create_rootvol_snapshot) or (root_device != @device_name and @instance.create_datavol_snapshot)
+    end
+
+    def freeze_filesystem(&block)
+      if @mount_point and @file_system == "xfs"
+        puts "freezing XFS filesystem" if @instance.verbose
+        Kernel.system("xfs_freeze -f #{@mount_point}")
+      end
+      
+      begin
+        yield
+      rescue Exception => ex
+        puts "exception thrown during snapshot creation: #{ex}" if @verbose
+      ensure
+        if @mount_point and @file_system == "xfs"
+          puts "unfreezing XFS filesystem" if @instance.verbose
+          Kernel.system("xfs_freeze -u #{@mount_point}")
+        end
+      end
+    end
+
+    def create_snapshot
+      puts "creating and tagging snapshot" if @instance.verbose
+      snapshot = @instance.ec2.create_snapshot(@volume_id, "#{@instance.hostname}: automated snapshot #{@device_name} (#{@volume_id})")
+      # The only way to set the name of a snapshot is by creating a name tag for the snapshot
+      @instance.ec2.create_tags(snapshot[:aws_id], { "Name" => "#{@instance.hostname} (#{@device_name})", "Hostname" => @instance.hostname })
+    end
+
+    def xfs_device_name
+      # Required for Ubuntu Natty Narwhal and up, which uses xvdX, while Amazon uses sdX
+      @device_name.gsub("/sd", "/xvd")
+    end
+
+    private
+
+    def init_mount_info
+      mounts = %x[cat /proc/mounts].split("\n")
+      mounts.each do |mount|
+        parts = mount.split(" ")
+        # Make sure that both Amazons volume naming and Ubuntu naming is matched
+        if [@device_name, xfs_device_name].include?(parts.first)
+          @mount_point = parts[1]
+          @file_system = parts[2]
+          break
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,3 @@
+require "minitest/mock"
+require "minitest/autorun"
+require "mocha"

data/test/test_instance.rb

@@ -0,0 +1,118 @@
+require 'ec2_snapshot/instance'
+require 'ec2_snapshot/volume'
+require File.expand_path("../helper", __FILE__)
+
+class InstanceTest < MiniTest::Unit::TestCase
+  def setup
+    # Mock system calls
+    Ec2Snapshot::Instance.any_instance.stubs(:`).returns("output")
+    Ec2Snapshot::Volume.any_instance.stubs(:`).returns("/dev/xvdf /srv xfs rw,noatime,attr2,delaylog,noquota 0 0")
+    # Mock right_aws init, return mock object and mock methods on that object
+    m = MiniTest::Mock.new
+    RightAws::Ec2.stubs(:new).returns(m)
+    m.stubs(:describe_instances).returns([{:root_device_type=>"ebs", :root_device_name=>"/dev/sda1", :block_device_mappings=>[{:device_name=>"/dev/sda1", :ebs_volume_id=>"vol-id1", :ebs_status=>"attached", :ebs_attach_time=>"2011-12-06T14:48:27.000Z", :ebs_delete_on_termination=>true}, {:device_name=>"/dev/sdf", :ebs_volume_id=>"vol-id2", :ebs_status=>"attached", :ebs_attach_time=>"2011-12-06T14:48:27.000Z", :ebs_delete_on_termination=>false}]}])
+
+    # Init Ec2Snapshot::Instance to work with
+    @instance = Ec2Snapshot::Instance.new({ :access_key => "accesskey", :secret_access_key => "secretkey", :region => "region" })
+  end
+
+  # new
+  def test_create_new_instance_should_fail_if_required_ec2_credentials_are_unavailable
+    assert_raises NoMethodError do
+      Ec2Snapshot::Instance.new(nil)
+    end
+  end
+
+  def test_create_new_instance_should_not_fail_if_required_ec2_credentials_are_available
+    assert_instance_of Ec2Snapshot::Instance, @instance
+  end
+
+  # custom_actions
+  def test_custom_actions_should_execute_before_action_if_set
+    Kernel.expects(:system).with("test")
+    @instance.before = "test"
+    @instance.custom_actions do
+      true
+    end
+  end
+
+  def test_custom_actions_should_execute_after_action_if_set
+    Kernel.expects(:system).with("test")
+    @instance.after = "test"
+    @instance.custom_actions do
+      true
+    end
+  end
+
+  def test_custom_actions_should_execute_after_action_even_if_block_throws_an_exception
+    Kernel.expects(:system).with("test")
+    @instance.after = "test"
+    @instance.custom_actions do
+      raise Exception
+    end
+  end
+
+  # enable_rootvol_snapshot
+  def test_enable_rootvol_snapshot_should_return_true
+    assert @instance.enable_rootvol_snapshot
+  end
+
+  def test_enable_rootvol_snapshot_should_set_instance_variable
+    assert !@instance.create_rootvol_snapshot
+    @instance.enable_rootvol_snapshot
+    assert @instance.create_rootvol_snapshot
+  end
+
+  # enable_datavol_snapshot
+  def test_enable_datavol_snapshot_should_return_true
+    assert @instance.enable_datavol_snapshot
+  end
+
+  def test_enable_datavol_snapshot_should_set_instance_variable
+    assert !@instance.create_datavol_snapshot
+    @instance.enable_datavol_snapshot
+    assert @instance.create_datavol_snapshot
+  end
+
+  # instance_id
+  def test_instance_id_should_return_a_string
+    assert_instance_of String, @instance.instance_id
+  end
+
+  def test_instance_id_should_return_output_of_wget_call
+    assert_equal "output", @instance.instance_id
+  end
+
+  # hostname
+  def test_hostname_should_return_a_string
+    assert_instance_of String, @instance.hostname
+  end
+
+  def test_hostname_should_return_hostname
+    assert_equal "output", @instance.instance_id
+  end
+
+  # root_device_name
+  def test_root_device_name_should_return_a_string_if_device_name_is_found
+    assert_instance_of String, @instance.root_device_name
+  end
+
+  def test_root_device_name_should_return_correct_metadata
+    assert_equal "/dev/sda1", @instance.root_device_name
+  end
+
+  # volumes
+  def test_volumes_should_return_an_array
+    assert_instance_of Array, @instance.volumes
+  end
+
+  def test_volumes_should_return_volume_objects
+    @instance.volumes.each do |vol|
+      assert_instance_of Ec2Snapshot::Volume, vol
+    end
+  end
+
+  def test_volumes_should_return_correct_number_of_volumes
+    assert_equal 2, @instance.volumes.count
+  end
+end

data/test/test_volume.rb

@@ -0,0 +1,76 @@
+require 'ec2_snapshot/volume'
+require File.expand_path("../helper", __FILE__)
+
+class VolumeTest < MiniTest::Unit::TestCase
+  def setup
+    # Mock system calls
+    Ec2Snapshot::Instance.any_instance.stubs(:`).returns("output")
+    Ec2Snapshot::Volume.any_instance.stubs(:`).returns("/dev/xvdf /srv xfs rw,noatime,attr2,delaylog,noquota 0 0")
+    # Mock right_aws init, return mock object and mock methods on that object
+    m = MiniTest::Mock.new
+    RightAws::Ec2.stubs(:new).returns(m)
+    m.stubs(:describe_instances).returns([{:root_device_type=>"ebs", :root_device_name=>"/dev/sda1", :block_device_mappings=>[{:device_name=>"/dev/sda1", :ebs_volume_id=>"vol-id1", :ebs_status=>"attached", :ebs_attach_time=>"2011-12-06T14:48:27.000Z", :ebs_delete_on_termination=>true}, {:device_name=>"/dev/sdf", :ebs_volume_id=>"vol-id2", :ebs_status=>"attached", :ebs_attach_time=>"2011-12-06T14:48:27.000Z", :ebs_delete_on_termination=>false}]}])
+    # Init Ec2Snapshot::Instance to work with
+    @instance = Ec2Snapshot::Instance.new({ :access_key => "accesskey", :secret_access_key => "secretkey", :region => "region" })
+  end
+
+  # freeze_filesystem
+  def test_freeze_filesystem_should_freeze_and_unfreeze_filesystem_if_filesystem_is_xfs
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    vol.file_system = "xfs"
+    Kernel.expects(:system).with("xfs_freeze -f /srv")
+    Kernel.expects(:system).with("xfs_freeze -u /srv")
+    vol.freeze_filesystem
+  end
+
+  def test_freeze_filesystem_shouldnt_freeze_and_unfreeze_filesystem_if_filesystem_is_not_xfs
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    vol.file_system = "fat32"
+    Kernel.expects(:system).never
+    vol.freeze_filesystem
+  end
+
+  def test_freeze_filesystem_should_freeze_and_unfreeze_filesystem_if_filesystem_is_xfs_and_block_throws_an_exception
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    vol.file_system = "xfs"
+    Kernel.expects(:system).with("xfs_freeze -f /srv")
+    Kernel.expects(:system).with("xfs_freeze -u /srv")
+    vol.freeze_filesystem do
+      raise Exception
+    end
+  end
+
+  # xfs_device_name
+  def test_xfs_device_name_should_return_a_string
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    assert_instance_of String, vol.xfs_device_name
+  end
+
+  def test_xfs_device_name_should_replace_device_name
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    assert_equal "/dev/xvdf", vol.xfs_device_name
+  end
+
+  # requires_snapshot
+  def test_requires_snapshot_should_return_true_if_volume_is_rootvol_and_rootvol_should_be_snapshotted
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sda1")
+    @instance.enable_rootvol_snapshot
+    assert vol.requires_snapshot
+  end
+
+  def test_requires_snapshot_should_return_false_if_volume_is_rootvol_and_rootvol_shouldnt_be_snapshotted
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sda1")
+    assert !vol.requires_snapshot
+  end
+
+  def test_requires_snapshot_should_return_true_if_volume_is_datavol_and_datavol_should_be_snapshotted
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    @instance.enable_datavol_snapshot
+    assert vol.requires_snapshot
+  end
+
+  def test_requires_snapshot_should_return_false_if_volume_is_datavol_and_datavol_shouldnt_be_snapshotted
+    vol = Ec2Snapshot::Volume.new(@instance, "volume-id", "/dev/sdf")
+    assert !vol.requires_snapshot
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: ec2-snapshot
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+- mattijsvandruenen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: right_aws
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.8.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: EC2 EBS Volume Snapshotting
+email: 
+- m.vandruenen@voormedia.com
+executables: 
+- ec2-snapshot
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/ec2-snapshot
+- ec2-snapshot.gemspec
+- lib/ec2-snapshot.rb
+- lib/ec2_snapshot.rb
+- lib/ec2_snapshot/instance.rb
+- lib/ec2_snapshot/version.rb
+- lib/ec2_snapshot/volume.rb
+- test/helper.rb
+- test/test_instance.rb
+- test/test_volume.rb
+homepage: https://github.com/voormedia/ec2-snapshot
+licenses: []
+
+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.8
+signing_key: 
+specification_version: 3
+summary: Create consistent snapshots of EBS volumes on Amazon EC2 instances.
+test_files: 
+- test/helper.rb
+- test/test_instance.rb
+- test/test_volume.rb