mongo-ec2-backup 0.0.4

data/Gemfile

@@ -0,0 +1,7 @@
+source :gemcutter
+
+gem "mongo"
+# crappy dependencies
+gem "bson_ext"
+gem "fog"
+gem "trollop"

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bson (1.3.1)
+    bson_ext (1.5.1)
+    builder (3.0.0)
+    excon (0.15.5)
+    fog (1.5.0)
+      builder
+      excon (~> 0.14)
+      formatador (~> 0.2.0)
+      mime-types
+      multi_json (~> 1.0)
+      net-scp (~> 1.0.4)
+      net-ssh (>= 2.1.3)
+      nokogiri (~> 1.5.0)
+      ruby-hmac
+    formatador (0.2.3)
+    mime-types (1.19)
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    multi_json (1.3.6)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.5.2)
+    nokogiri (1.5.5)
+    ruby-hmac (0.4.0)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson_ext
+  fog
+  mongo
+  trollop

data/LICENCE

@@ -0,0 +1,24 @@
+#  Copyright (c) 2011 Fotonauts
+# All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of the Fotonauts, Fotopedia nor the
+#       names of its contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# OSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,68 @@
+# Mongo consistent backup over RAID EBS disks on EC2 instance
+
+Suite of tools to backup and manage snapshots of MongoDB data set to EC2 Snapshots.
+
+## Lock and Snapshot: lock_and_snapshot.rb
+
+### Usage
+
+Snapshot a list of devices on a given instance on ec2. Requires network access in order to lock and unlock Mongo
+
+```shell
+./lock_and_snapshot.rb -a ACCESS_KEY_ID -s SECRET_ACCESS_KEY --hostname server01 --devices /dev/sdl,/dev/slm --type daily --limit 4
+```
+
+* --port, -p <i>:   Mongo port to connect to (default: 27017)
+* --access-key-id, -a <s>:   Access Key Id for AWS
+* --secret-access-key, -s <s>:   Secret Access Key for AWS
+* --devices, -d <s>:   Devices to snapshot, comma separated
+* --hostname, -h <s>:   Hostname to look for. Should resolve to a local EC2 Ip
+* --type, -t <s>:   Snapshot type, to choose among snapshot,weekly,monthly,daily,yearly (default: snapshot)
+* --limit, -l <i>:   Cleanup old snapshots to keep only limit snapshots. Default values are stored in EC2VolumeSnapshoter::KIND
+* --region:   Region hosting the instances
+* --help, -e:   Show this message
+
+### Usage in chef environment
+
+In order to run the command from a remote server (the Chef server or any administrative node of your grid), you need to be able to know the lists of the devices you wish to snapshot.
+
+By using the ohai-raid plugin (https://github.com/octplane/ohai-raid), Chef clients can fill part of their Chef registry with information about the software managed RAID arrays running.
+This information can be fetched out for use at a later point via the knife script provided in the ohai-raid package:
+
+```
+knife exec scripts/show_raid_devices server01.fqdn.com /dev/md0
+/dev/sdl,/dev/sdm,/dev/sdn,/dev/sdo
+```
+
+You can combine the two tools to automate daily backup of you MongoDB server:
+
+```
+./lock_and_snapshot.rb -a ACCESS_KEY_ID -s SECRET_ACCESS_KEY --hostname server01 --devices $(knife exec /path/to/scripts/show_raid_devices server01.fqdn.com /dev/md0) --type daily
+```
+
+### Tool Description
+
+* Find instance id by resolving the hostname provided in the CLI and scanning the instances in EC2
+* Lock Mongo by connecting via the hostname:port provided in the parameters
+* Snapshot the disks, delete old backups
+* Unlock Mongo
+
+## MD inspection: ec2-consistent-backup.rb
+
+### Usage
+
+This script demonstrates the way it analyses Mongo DB Data path to extract the MD device and components associated
+
+```shell
+./ec2-consistent-backup -p 27017 
+```
+
+### Tool description
+
+* connect to mongo at port provided, retrieves dbpath
+* find what mount this dbpath corresponds to
+* use /proc/mdstat to find out which drive are corresponding to the dbpath mount disk
+
+# API
+
+Internal API documentation is at: http://rubydoc.info/github/octplane/mongo-ec2-consistent-backup/master/frames

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require "rake/clean"
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+desc "Packages up Swissr."
+task :default => :package
+
+spec = Gem::Specification.new do |s|
+  s.name    = 'mongo-ec2-backup'
+  s.version = '0.0.4'
+  s.summary = 'Snapshot your mongodb in the EC2 cloud via XFS Freeze'
+
+  s.author   = 'Pierre Baillet'
+  s.email    = 'oct@fotopedia.com'
+  s.homepage = 'https://github.com/octplane/mongo-ec2-consistent-backup'
+
+  # These dependencies are only for people who work on this gem
+  s.add_dependency 'fog'
+  s.add_dependency 'bson_ext'
+  s.add_dependency 'trollop'
+  s.add_dependency 'mongo'
+
+  # Include everything in the lib folder
+  s.files = FileList['lib/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*'].to_a
+
+  s.executables << "mongo_lock_and_snapshot"
+
+  # Supress the warning about no rubyforge project
+  s.rubyforge_project = 'nowarning'
+end
+
+Rake::GemPackageTask.new(spec) do |package| 
+  package.gem_spec = spec
+  # package.need_tar = true 
+  # package.need_zip = true
+end

data/bin/mongo_lock_and_snapshot

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# Lock a set of disk via the mongo lock command and snapshot them to the cloud
+
+require 'rubygems'
+ENV['BUNDLE_GEMFILE'] =  File.join(File.dirname(__FILE__), "..", "Gemfile")
+require 'bundler/setup'
+require 'trollop'
+
+$: << File.join("..", File.dirname(__FILE__), "lib")
+require 'ec2-consistent-backup'
+require 'ec2_volume_snapshoter'
+
+opts = Trollop::options do
+  opt :path, "Data path to freeze", :type => :string, :required => true
+  opt :access_key_id, "Access Key Id for AWS", :type => :string, :required => true
+  opt :secret_access_key, "Secret Access Key for AWS", :type => :string, :required => true
+  opt :devices, "Devices to snapshot, comma separated", :type => :string, :required => true
+  opt :type, "Snapshot type, to choose among #{EC2VolumeSnapshoter::KINDS.keys.join(",")}", :default => "snapshot"
+  opt :limit, "Cleanup old snapshots to keep only limit snapshots", :type => :integer
+end
+
+# find instance id by
+#  - resolving name to ip
+#  - looking in EC2 for server
+# Lock Mongo
+# Snapshot
+# Unlock
+
+aki = opts[:access_key_id]
+sak = opts[:secret_access_key]
+path = opts[:path]
+
+`/usr/sbin/xfs_freeze -f #{path}`
+
+begin
+  snapshoter = EC2VolumeSnapshoter.new(aki, sak)
+  limit = if opts[:limit] == nil
+    EC2VolumeSnapshoter::KINDS[opts[:type]]
+  else
+    opts[:limit]
+  end
+
+  snapshoter.snapshot_devices(opts[:devices].split(/,/), "Mongo Snapshot", opts[:type], limit)
+rescue Exception => e
+  require "pp"
+  puts e.inspect  
+  pp e.backtrace
+ensure
+  `/usr/sbin/xfs_freeze -u #{path}`
+end

data/lib/ec2-consistent-backup.rb

@@ -0,0 +1,169 @@
+require 'rubygems'
+require 'mongo'
+require 'open-uri'
+
+=begin
+- check S3 credentials
+- check disk location of data
+- check this is on a remotely mounted disk (or md drive)
+- http://www.mongodb.org/display/DOCS/getCmdLineOpts+command
+=end
+
+
+=begin
+/proc/mdstat content:
+
+Personalities : [raid0] 
+md0 : active raid0 sdo[3] sdn[2] sdm[1] sdl[0]
+      838859776 blocks 256k chunks
+      
+unused devices: <none>
+=end
+class NoSuchSetException < Exception; end
+# Parse the existing RAID sets by reading /prod/mdstat
+# Cheap alternative to using FFI to interface with libdm
+class MDInspector
+  MDFILE = "/proc/mdstat"
+  PERSONALITIES = "Personalities :"
+  attr_reader :has_md, :personalities
+  attr_reader :drives
+  def initialize(mdfile = MDFILE)
+    @has_md = false
+    if File.exists?(mdfile)
+      stat_data = File.open(mdfile).read.split(/\n/)
+      personalities_line = stat_data.grep(/#{PERSONALITIES}/)
+      if personalities_line =~ /#{PERSONALITIES}(.+)/
+        @personalities =  $1
+      else
+        @has_md = false
+      end
+      @set_metadata = {}
+      stat_data.grep(/^md[0-9]+ : /).each do |md_info|
+        if md_info =~ /^md([0-9]+) : active ([^ ]+) (.*)$/
+          set_name = "md#{$1}"
+          personality = $2
+          drives = $3.split(/ /).map{ |i| "/dev/"+i.gsub(/\[[0-9]+\]/,'') }.to_a
+          @set_metadata[set_name] =  { :set_name=> set_name, :personality => personality, 
+            :drives => drives}
+        end
+      end
+      @has_md = true if @set_metadata.keys.length > 0
+    end
+  end
+  # Returns the information about the MD set @name
+  def set(name)
+    # Handle "/dev/foobar" instead of "foobar"
+    if name =~ /\/dev\/(.*)$/
+      name = $1
+    end
+    return @set_metadata[name] if @set_metadata.has_key?(name)
+    raise NoSuchSetException.new(name)
+  end
+end
+
+class NotMountedException < Exception; end
+class MountInspector
+  def initialize(file = '/etc/mtab')
+    @dev_to_fs = {}
+    @fs_to_dev = {}
+    File.open(file).read.split(/\n/).map {|line| line.split(/ /)[0..1]}.each do |m|
+      @dev_to_fs[m[0]] = m[1] if m[0] != "none"
+      @fs_to_dev[m[1]] = m[0] if m[1] != "none"
+    end
+  end
+  def where_is_mounted(device)
+    return @dev_to_fs[device] if @dev_to_fs.has_key?(device) 
+    raise NotMountedException.new(device)
+  end
+  def which_device(folder)
+    # Level 0 optimisation+ Handle "/" folder
+    return @fs_to_dev[folder] if @fs_to_dev.has_key?(folder)
+
+    components = folder.split(/\//)
+    components.size.downto(0).each do |sz|
+      current_folder = components[0..sz-1].join("/")
+      current_folder = "/" if current_folder == ""
+      return @fs_to_dev[current_folder] if @fs_to_dev.has_key?(current_folder)
+    end
+    raise NotMountedException.new(folder)
+  end
+end
+
+module MongoHelper
+  class DataLocker
+    attr_reader :path
+    def initialize(port = 27017, host = 'localhost')
+      @m = Mongo::Connection.new(host, port)
+      args =  @m['admin'].command({'getCmdLineOpts' => 1 })['argv']
+      p = args.index('--dbpath')
+      @path = args[p+1]
+      @path = File.readlink(@path) if File.symlink?(@path)
+
+    end
+    def lock
+      return if locked?
+      @m.lock!
+      while !locked? do
+        sleep(1)
+      end
+      raise "Not locked as asked" if !locked?
+    end
+    def locked?
+      @m.locked?
+    end
+    def unlock
+      return if !locked?
+      raise "Already unlocked" if !locked?
+      @m.unlock!
+      while locked? do
+        sleep(1)
+      end
+    end
+  end
+end
+
+def log s
+  $stderr.puts "[#{Time.now}]: #{s}"
+end
+
+if __FILE__ == $0
+  require 'trollop'
+  opts = Trollop::options do
+    opt :port, "Mongo port to connect to", :default => 27017
+  end
+
+  # First connect to mongo and find the dbpath
+  port = opts[:port]
+  m = MongoHelper::DataLocker.new(port)
+  data_location = m.path
+  log "Mongo at #{port} has its data in #{data_location}."
+  
+
+  mount_inspector = MountInspector.new
+  raid_set = mount_inspector.which_device(data_location)
+  log "This path is on the device #{raid_set}."
+
+  begin 
+    raid_sets = MDInspector.new
+    drives = raid_sets.set(raid_set)[:drives]
+
+    log "This device is the MD device built with #{drives.inspect}."
+
+    # # this code probably works, but is way to dangerous.
+    # m.lock
+    # begin
+    #   log "Locked mongo"
+    #   e = EC2VolumeSnapshoter.new(opts[:access_key_id], opts[:secret_access_key], opts[:region])
+    #   e.snapshot_devices(drives)
+    # rescue Exception => e
+    #   puts e.inspect
+    # ensure
+    #   m.unlock
+    #   log "Unlocked mongo"
+    # end
+    
+  rescue NoSuchSetException => e
+    log "Device #{raid_set} is not a MD device, bailing out"
+    raise e
+  end
+end

data/lib/ec2_instance_identifier.rb

@@ -0,0 +1,32 @@
+require 'resolv'
+require 'fog'
+
+class EC2InstanceNotFoundException < Exception; end
+# Fetch an instance from its private ip address
+class EC2InstanceIdentifier
+  # Need access_key_id, secret_access_key
+  def initialize(aki, sak)
+    @compute = Fog::Compute.new({:provider => 'AWS', :aws_access_key_id => aki, :aws_secret_access_key => sak})
+  end
+  # Returns the instance corresponding to the provided hostname
+  def get_instance(hostname)
+    ip = Resolv.getaddress(hostname)
+    instance = @compute.servers.all().find { |i| i.private_ip_address  == ip || i.public_ip_address == ip }
+    raise InstanceNotFoundException.new(hostname) if ! instance
+    return instance
+  end
+end
+
+if __FILE__ == $0
+  require 'trollop'
+  require 'pp'
+  opts = Trollop::options do
+    opt :access_key_id, "Access Key Id for AWS", :type => :string, :required => true
+    opt :secret_access_key, "Secret Access Key for AWS", :type => :string, :required => true
+    opt :hostname, "Hostname to look for. Should resolve to a local EC2 Ip", :type => :string, :required => true
+  end
+
+  eii = EC2InstanceIdentifier.new(opts[:access_key_id], opts[:secret_access_key])
+  pp eii.get_instance(opts[:hostname])
+
+end

data/lib/ec2_snapshot_restorer.rb

@@ -0,0 +1,34 @@
+require 'fog'
+require 'open-uri'
+
+
+# 
+class SnapshotRestorer
+  def initialize(aki, sak, snap_ids)
+    @compute = Fog::Compute.new({:provider => 'AWS', :aws_access_key_id => aki, :aws_secret_access_key => sak})
+    @snaps = snap_ids
+    @volumes = []
+  end
+  def restore()
+    @snaps.each do | resource_id |
+      snap = @compute.snapshots.get(resource_id)
+      # Snap have the following tags
+      # application
+      # device
+      # instance_id
+      # date
+      # kind
+
+      t =  snap.tags
+      volume = @compute.volumes.new :snapshot_id => snap.id, :size => snap.volume_size, :availability_zone => 'us-east-1c'
+      @compute.tags.create(:resource_id => volume.id, :key =>"application", :value => NAME_PREFIX)
+      @compute.tags.create(:resource_id => volume.id, :key =>"device", :value => device)
+      @compute.tags.create(:resource_id => volume.id, :key =>"date", :value => ts)
+      @compute.tags.create(:resource_id => volume.id, :key =>"kind", :value => kind)
+      volume.save
+      @volumes << volume
+    end
+  end
+  def connect(instance_id = open("http://169.254.169.254/latest/meta-data/instance-id").read)
+  end
+end

data/lib/ec2_volume_snapshoter.rb

@@ -0,0 +1,169 @@
+require 'fog'
+require 'open-uri'
+
+# This class is responsible of the snapshoting of given disks to EC2
+# EC2 related permissions in IAM
+# Sid": "Stmt1344254048404",
+#      "Action": [
+#        "ec2:CreateSnapshot",
+#        "ec2:DeleteSnapshot",
+#        "ec2:DescribeSnapshots",
+#        "ec2:CreateTags",
+#        "ec2:DescribeTags",
+#        "ec2:DescribeVolumes"
+#      ],
+#      "Effect": "Allow",
+#      "Resource": [
+#        "*"
+#      ]
+#
+
+class NoSuchVolumeException < Exception
+  def initialize(instance, volume, details)
+    @instance, @volume, @details = instance, volume, details
+  end
+  def to_s
+    "Unable to locate volume \"#{@volume}\" on #{@instance}\nKnow volumes for this instance are:\n#{@details.inspect}"
+  end
+end
+
+def log s
+ $stderr.puts "[#{Time.now}]: #{s}"
+end
+
+class EC2VolumeSnapshoter
+  NAME_PREFIX='Volume Snapshot'
+
+  # Kind of snapshot and their expiration in days
+  KINDS = { 'test' => 1,
+    'snapshot' => 0,
+    'daily' => 7,
+    'weekly' => 31,
+    'monthly' => 300,
+    'yearly' => 0}
+
+  attr_reader :instance_id
+  # Need access_key_id, secret_access_key and instance_id
+  # If not provided, attempt to fetch current instance_id
+  def initialize(aki, sak, instance_id = open("http://169.254.169.254/latest/meta-data/instance-id").read)
+
+    @instance_id = instance_id
+
+    @compute = Fog::Compute.new({:provider => 'AWS', :aws_access_key_id => aki, :aws_secret_access_key => sak})
+  end
+  # Snapshots the list of devices 
+  # devices is an array of device attached to the instance (/dev/foo)
+  # name if the name of the snapshot
+  def snapshot_devices(devices, name = "#{instance_id}", kind = "test", limit = KINDS[kind])
+    log "Snapshot of kind #{kind}, limit set to #{limit} (0 means never purge)"
+    ts = DateTime.now.to_s
+    name = "#{NAME_PREFIX}:" + name
+    volumes = {}
+    devices.each do |device|
+      volumes[device] = find_volume_for_device(device)
+    end
+    sn = []
+    volumes.each do |device, volume|
+      log "Creating volume snapshot for #{device} on instance #{instance_id}"
+      snapshot = volume.snapshots.new
+      snapshot.description = name+" #{device}"
+      snapshot.save
+      sn << snapshot
+      snapshot.reload
+
+      @compute.tags.create(:resource_id => snapshot.id, :key =>"application", :value => NAME_PREFIX)
+      @compute.tags.create(:resource_id => snapshot.id, :key =>"device", :value => device)
+      @compute.tags.create(:resource_id => snapshot.id, :key =>"instance_id", :value =>instance_id)
+      @compute.tags.create(:resource_id => snapshot.id, :key =>"date", :value => ts)
+      @compute.tags.create(:resource_id => snapshot.id, :key =>"kind", :value => kind)
+
+    end
+    log "Waiting for snapshots to complete."
+    sn.each do |s|
+      begin
+        sleep(3)
+        s.reload
+      end while s.state == 'nil' || s.state == 'pending'
+    end
+
+    if limit != 0
+      # populate data structure with updated information
+      snapshots = list_snapshots(devices, kind)
+      nsnaps = snapshots.keys.length
+      if nsnaps-limit > 0
+        dates = snapshots.keys.sort
+        puts dates.inspect
+        extra_snapshots = dates[0..-limit]
+        remaining_snapshots = dates[-limit..-1]
+        extra_snapshots.each do |date|
+          snapshots[date].each do |snap|
+            log "Destroying #{snap.description} #{snap.id}"
+            snap.destroy
+         end
+        end
+      end
+    end
+  end
+
+  # List snapshots for a set of device and a given kind
+  require 'pp'
+  def list_snapshots(devices, kind)
+    volume_map = []
+    snapshots = {}
+
+    tags = @compute.tags.all(:key => 'instance_id', :value => instance_id)
+    tags.each do |tag|
+      snap = @compute.snapshots.get(tag.resource_id)
+      t =  snap.tags
+
+      if devices.include?(t['device']) && 
+        instance_id == t['instance_id'] &&
+        NAME_PREFIX == t['application'] &&
+        kind == t['kind']
+        snapshots[t['date']] ||= []
+        snapshots[t['date']] << snap
+      end
+    end
+
+    # take out incomplete backups
+    snapshots.delete_if{ |date, snaps| snaps.length != devices.length }
+    snapshots
+  end
+
+
+  def find_volume_for_device(device)
+    my = []
+    @compute.volumes.all().each do |volume|
+      if volume.server_id == @instance_id
+        my << volume
+        if volume.device == device
+          return volume
+        end
+      end
+    end
+    raise NoSuchVolumeException.new(@instance_id, device, my)
+  end
+end
+
+if __FILE__ == $0
+  require 'trollop'
+  require 'pp'
+
+  opts = Trollop::options do
+    opt :access_key_id, "Access Key Id for AWS", :type => :string, :required => true
+    opt :secret_access_key, "Secret Access Key for AWS", :type => :string, :required => true
+    opt :instance_id, "Instance identifier", :type => :string, :required => true
+    opt :find_volume_for, "Show information for device path (mount point)", :type => :string
+    opt :snapshot, "Snapshot device path (mount point)", :type => :string
+    opt :snapshot_type, "Kind of snapshot (any of #{EC2VolumeSnapshoter::KINDS.keys.join(", ")})", :default => 'test'
+
+  end
+
+  evs = EC2VolumeSnapshoter.new(opts[:access_key_id], opts[:secret_access_key], opts[:instance_id])
+  if opts[:find_volume_for]
+    pp evs.find_volume_for_device(opts[:find_volume_for])
+  end
+  if opts[:snapshot]
+    evs.snapshot_devices([opts[:snapshot]])
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: mongo-ec2-backup
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Pierre Baillet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  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: bson_ext
+  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: trollop
+  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: mongo
+  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'
+description: 
+email: oct@fotopedia.com
+executables:
+- mongo_lock_and_snapshot
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ec2-consistent-backup.rb
+- lib/ec2_instance_identifier.rb
+- lib/ec2_snapshot_restorer.rb
+- lib/ec2_volume_snapshoter.rb
+- bin/mongo_lock_and_snapshot
+- Gemfile
+- Gemfile.lock
+- LICENCE
+- Rakefile
+- README.markdown
+homepage: https://github.com/octplane/mongo-ec2-consistent-backup
+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: nowarning
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Snapshot your mongodb in the EC2 cloud via XFS Freeze
+test_files: []