appshot 0.0.1

data/lib/appshot.rb

@@ -0,0 +1,93 @@
+require 'appshot/version'
+require 'appshot/volume'
+require 'appshot/app'
+require 'appshot/filesystem'
+require 'awesome_print'
+
+class Appshot
+  def initialize(config)
+    @appshots = {}
+		@callables = []
+    instance_eval(config)
+  end
+
+  def empty?
+    true
+  end
+
+  def appshot_count
+    @appshots.size
+  end
+
+  def appshot_names
+    @appshots ? @appshots.keys : []
+  end
+
+  ##############
+  # DSL Keywords
+  ##############
+  def appshot(appshot_name, &block)
+    if block_given?
+      @callables = []
+      @appshots[appshot_name.to_s] = instance_eval(&block)
+    end
+  end
+
+  def comment(arg)
+    @callables
+  end
+
+  def xfs(args={})
+    @callables << Appshot::DM.new(args)
+  end
+
+  def ext4(args={})
+    @callables << Appshot::DM.new(args)
+  end
+
+  def ebs_snapshot(args={})
+    @callables << Appshot::EBS_Snapshot.new(args)
+  end
+
+	def mysql(args={})
+		@callables << Appshot::Mysql.new(args)
+	end
+
+	def ebs_prune(args={})
+    @callables << Appshot::EBS_Prune.new(args)
+	end
+
+	###############
+	# Internals
+	###############
+
+  def appshots
+    @appshots
+  end
+
+  def execute_callables
+    @appshots.each do |appshot, callable|
+      first_call = callable.shift
+      first_call.call(callable) unless first_call.nil?
+    end
+  end
+
+  def run_pass(options, args)
+    if options["list-appshots"]
+      puts list_appshots if options["list-appshots"]
+    else
+      execute_callables unless options["trial-run"]
+    end
+  end
+
+  def list_appshots
+    case @appshots.count
+    when 0
+      "There are no appshots configured"
+    when 1
+      "There is one appshot configured: #{@appshots.keys.first.to_s}"
+    else
+      "There are #{@appshots.count} appshots configured: #{@appshots.keys.join(', ')}"
+    end
+  end
+end

data/rvmrc.example

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.10.2" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+  if [[ $- == *i* ]] # check for interactive shells
+  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | grep -vE '^Using|Your bundle is complete'
+# fi

data/spec/lib/appshot/app/mysql_spec.rb

@@ -0,0 +1,37 @@
+require 'appshot/app/mysql'
+require 'awesome_print'
+
+describe Appshot::Mysql do
+  subject { Appshot::Mysql.new }
+  it { should be_a_kind_of Appshot::Mysql }
+  it { subject.respond_to?(:call).should be_true }
+
+  describe "#call" do
+    before do
+      Mysql2::Client.stub(:new).and_return(mysql)
+    end
+    let(:mysql) { double(:mysql2, query: true, close: true) }
+
+    it "should require an argument to #call" do
+      lambda { subject.call }.should raise_error(ArgumentError)
+    end
+
+    it "should invoke #call on the next object in the call_chain" do
+      items = [double(:appshot1), double(:appshot2)]
+      items.first.should_receive(:call).with(items).and_return(true)
+      subject.call(items)
+    end
+
+    it "should run #lock before call is invoked" do
+      items = [Appshot::Mysql.new, Appshot::Mysql.new]
+      items.first.should_receive(:lock)
+      subject.call(items)
+    end
+
+    it "should run #unlock after call is invoked" do
+      items = [Appshot::Mysql.new, Appshot::Mysql.new]
+      items.first.should_receive(:unlock)
+      subject.call(items)
+    end
+  end
+end

data/spec/lib/appshot/filesystem/dm_spec.rb

@@ -0,0 +1,39 @@
+require 'appshot/filesystem/dm'
+
+describe Appshot::DM do
+  subject {
+    Appshot::DM.any_instance.stub(validate_mount_point: true)
+    Appshot::DM.new(mount_point: "/")
+  }
+
+  it { should be_a_kind_of Appshot::DM }
+  it { subject.respond_to?(:call).should be_true }
+
+  describe "#call" do
+    it "should invoke #call on the next object in the call_chain" do
+      Appshot::DM.any_instance.stub(:freeze).and_return(true)
+      Appshot::DM.any_instance.stub(:unfreeze).and_return(true)
+      items = [double(:appshot1), double(:appshot2)]
+      items.first.should_receive(:call).with(items).and_return(true)
+      subject.call(items)
+    end
+
+    it "should run #freeze and #unfreeze around a call being invoked" do
+      Appshot::DM.any_instance.stub(validate_mount_point: true)
+      first_dm = Appshot::DM.new(mount_point: "/tmp/fake_mount")
+      first_dm.stub(:freeze).and_return(true)
+      first_dm.stub(:unfreeze).and_return(true)
+      items = [double(:appshot_dm)]
+      items.first.should_receive(:call).with([]).and_return(true)
+      first_dm.call(items)
+    end
+
+    it "should not allow root paths" do
+      lambda{ Appshot::DM.new(mount_point: "/") }.should raise_error "We cannot currently unfreeze the root filesystem, leaving your system unusable. Aborting."
+    end
+
+    it "should verify that the given mount point exists and is actually a mount point" do
+      lambda{ Appshot::DM.new(mount_point: "/tmp/fake_mount_for_appshot_testing") }.should raise_error "Your mount point: '/tmp/fake_mount_for_appshot_testing' is not a mount point!"
+    end
+  end
+end

data/spec/lib/appshot/volume/ebs_prune_spec.rb

@@ -0,0 +1,39 @@
+require "appshot/volume/ebs_prune"
+
+describe Appshot::EBS_Prune do
+  subject { Appshot::EBS_Prune.new }
+
+  it { should be_a_kind_of Appshot::EBS_Prune }
+  it { subject.respond_to?(:call).should be_true }
+
+  it "should invoke #call on the next object in the call_chain" do
+    next_item = [double(:appshot)]
+    subject.should_receive(:call).with(next_item).and_return(true)
+    subject.call(next_item)
+  end
+  describe "validating arguments" do
+    let(:opts) { { volume_id: "vol-eba11eee", snapshots_to_keep: 10, minimum_retention_days: 5, aws_access_key_id: "BOO", aws_secret_access_key: "YAH" } }
+    subject { Appshot::EBS_Prune.new(final_opts) }
+
+    context "with no volume_id" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :volume_id } }
+      it "requires a volume_id argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "volume_id must be specified for an ebs_prune"
+      end
+    end
+
+    context "with no aws_access_key_id" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :aws_access_key_id } }
+      it "requires a aws_access_key_id argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "aws_access_key_id must be specified for an ebs_prune"
+      end
+    end
+
+    context "with no aws_secret_access_key" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :aws_secret_access_key } }
+      it "requires a aws_secret_access_key argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "aws_secret_access_key must be specified for an ebs_prune"
+      end
+    end
+  end
+end

data/spec/lib/appshot/volume/ebs_snapshot_spec.rb

@@ -0,0 +1,43 @@
+require 'appshot/volume/ebs_snapshot'
+
+describe Appshot::EBS_Snapshot do
+
+  subject { Appshot::EBS_Snapshot.new }
+
+  it { should be_a_kind_of Appshot::EBS_Snapshot }
+  it { subject.respond_to?(:call).should be_true }
+
+  it "should invoke #call on the next object in the call_chain" do
+    next_item = [double(:appshot)]
+    subject.should_receive(:call).with(next_item).and_return(true)
+    subject.call(next_item)
+  end
+
+  describe "validating arguments" do
+    let(:opts) { { volume_id: "vol-12341234", aws_access_key_id: "BOO", aws_secret_access_key: "YAH"  } }
+    subject { Appshot::EBS_Snapshot.new(final_opts) }
+
+    context "with no volume_id" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :volume_id } }
+      it "requires a volume_id argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "volume_id must be specified for an ebs_snapshot"
+      end
+    end
+
+    context "with no aws_access_key_id" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :aws_access_key_id } }
+      it "requires an aws_access_key_id argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "aws_access_key_id must be specified for an ebs_snapshot"
+      end
+    end
+
+    context "with no aws_secret_access_key" do
+      let(:final_opts) { opts.delete_if { |k,v| k == :aws_secret_access_key } }
+      it "requires an aws_secret_access_key argument" do
+        lambda { subject.valid? }.should raise_error ArgumentError, "aws_secret_access_key must be specified for an ebs_snapshot"
+      end
+    end
+  end
+
+
+end

data/spec/lib/appshot/volume/ebs_volume_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "appshot"
+require "appshot/volume"
+require "appshot/volume/ebs_volume"
+require "timecop"
+
+describe Appshot::EBS_Volume do
+  before do
+    Fog::Compute::AWS::Mock.reset
+    Fog.mock!
+  end
+
+  let(:ebs) { described_class.new(:provider => 'AWS',
+                                  :region => region,
+                                  :aws_access_key_id => aws_access_key_id,
+                                  :aws_secret_access_key => aws_secret_access_key,
+                                 ) }
+  let(:fog_compute) { ebs.instance_variable_get(:@fog)  }
+  let(:region) { "us-east-1" }
+  let(:aws_access_key_id) { "access_key_shhh" }
+  let(:aws_secret_access_key) { "secret_key_shhh" }
+
+  describe "basic setup" do
+    it "should be a class" do
+      described_class.should be_a_kind_of Class
+    end
+
+    it "should have a volume_id" do
+      ebs.respond_to?(:volume_id).should be_true
+    end
+  end
+
+  describe "given a volume_id" do
+    let(:snapshot_count) { 2 }
+    let(:volume_id)  { volumes.first.id }
+
+    let(:volumes) do
+      with_no_mock_delay do
+        [ create_volume("us-east-1a"),
+          create_volume("us-east-1b"), ]
+      end
+    end
+
+    let(:snaps) do
+      with_no_mock_delay do
+        snapshot_count.times do |i|
+          ebs.snap(volume_id, "This is test snapshot ##{i}")
+        end
+        ebs.snapshots_for(volume_id)
+      end
+    end
+
+    it "should create a snap id with a valid format" do
+      snaps.first.id.should =~ /^snap-*/
+    end
+
+    it "must finish a snapshot of the volume" do
+      snaps.first.state.should == "completed"
+    end
+
+    it "should know how many snapshots there are for a given volume" do
+      snaps
+      ebs.snapshots_for(volumes.first.id).count.should == 2
+      ebs.snapshots_for(volumes.last.id).count.should == 0
+    end
+
+    describe "pruning snapshots" do
+      context "with a minimum age" do
+        let(:snapshot_count) { 5 }
+
+        it "should not prune snapshots younger than the minimum age" do
+          with_no_mock_delay do
+            Timecop.freeze(Time.now - (3 * 86400))
+            ebs.snap(volume_id, "This is test snapshot #2")
+            Timecop.freeze(Time.now + 86400)
+            ebs.snap(volume_id, "This is test snapshot #3")
+            Timecop.freeze(Time.now + 86400)
+            ebs.snap(volume_id, "This is test snapshot #4")
+            Timecop.return
+          end
+          ebs.snapshots_for(volumes.first.id).count.should == 3
+          ebs.prune_snapshots(volumes.first.id, snapshots_to_keep: 1, not_after_time: Time.now - (3 * 86400))
+          ebs.snapshots_for(volumes.first.id).count.should == 2
+        end
+      end
+
+      context "without a minimum age" do
+        let(:snapshot_count) { 3 }
+
+        it "should prune snapshots for a given volume to a snapshot count" do
+          snaps
+          ebs.snapshots_for(volumes.first.id).count.should == 3
+          ebs.prune_snapshots(volumes.first.id, snapshots_to_keep: 1)
+          ebs.snapshots_for(volumes.first.id).count.should == 1
+        end
+      end
+    end
+  end
+end
+
+private
+
+def create_server(zone = "us-east-1" + %w(a b c d).sample)
+  with_no_mock_delay do
+    new_server = fog_compute.servers.create
+    new_server.reload.id
+  end
+end
+
+def create_volume(zone = "us-east-1" + %w(a b c d).sample, size = 20)
+  with_no_mock_delay do
+    new_volume = fog_compute.volumes.create(:availability_zone => zone, :size => size)
+    new_volume.reload
+  end
+end
+
+def with_no_mock_delay
+  delay = Fog::Mock.delay
+  Fog::Mock.delay = 0
+  return_object = yield
+  Fog::Mock.delay = delay
+  return_object
+end
+
+

data/spec/lib/appshot_spec.rb

@@ -0,0 +1,64 @@
+require "appshot"
+require 'awesome_print'
+
+describe Appshot do
+
+  let(:app) { Appshot.new("") }
+
+  it "is a class" do
+    described_class.should be_a_kind_of Class
+  end
+
+  it "has a method #appshot" do
+    app.respond_to?(:appshot).should be_true
+  end
+
+  describe "#appshot" do
+    it "should not add an appshot with an empty block" do
+      app.appshot_count.should == 0
+      app.appshot("my_account")
+      app.appshot_count.should == 0
+    end
+
+    it "should add an appshot to the store" do
+      app.appshot_count.should == 0
+      app.appshot("my_account") {}
+      app.appshot_count.should == 1
+    end
+
+    it "should add an appshot with the right name" do
+      app.appshot("my_account") {}
+      app.appshot_names.include?("my_account").should be_true
+    end
+
+    it "should accept a block" do
+      app.appshot("my_account") do
+        comment "my_account snapshot run"
+      end
+      app.appshots["my_account"].should_not be_nil
+    end
+  end
+
+  describe "#list_appshots" do
+    context "with no appshots in config file" do
+      it "should give a 'no appshots' message" do
+        app.list_appshots.should == "There are no appshots configured"
+      end
+    end
+    context "with one appshot in config file" do
+      it "should give a 'one appshot' message" do
+        app.appshot("one") {}
+        app.list_appshots.should == "There is one appshot configured: one"
+      end
+    end
+  end
+
+  describe "running an appshot" do
+    it "should run appshots" do
+      app.appshot("my_account") do
+        comment "my account snapshot execute"
+      end
+      app.execute_callables
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'awesome_print'
+require 'pry'
+
+RSpec.configure do |config|
+  config.mock_framework = :rspec
+  config.treat_symbols_as_metadata_keys_with_true_values = true # default in RSpec 3
+end