vgh 0.1.2 → 0.2.0

data/lib/vgh/ec2/snapshot.rb

@@ -0,0 +1,112 @@
+module VGH
+
+  # Creates the snapshots
+  def snap_and_tag(*args)
+    EC2::Snapshot.new(*args)
+  end
+
+module EC2
+
+# Creates a snapshot of the specified volume.
+#
+# == Usage
+#
+#     Snapshot.new(volume_id, description, tags)
+#
+class Snapshot
+
+  # Create and tag snapshot, and also purge expired ones
+  # @param [String] volume_id The ID of the volume to snapshot
+  # @param [String] description The description for the new snapshot
+  # @param [Hash] tags A Hash containing the names and values of the tags
+  # @return [Snapshot] The Snapshot object.
+  def initialize(volume_id, description, tags)
+    @volume_id   = volume_id
+    @description = description
+    @tags        = tags
+    create_snapshot
+    tag_snapshot
+    purge_backups
+    return snapshot
+  end
+
+  # @return [String] The Volume ID
+  attr_reader :volume_id
+
+  # @return [String] The description of the snapshot
+  attr_reader :description
+
+  # @return [Hash] The tags hash
+  attr_reader :tags
+
+  # @return [Object] The Snapshot object
+  attr_reader :snapshot
+
+  # Creates a snapshot for the specified volume
+  # @return [Object] The newly created snapshot object
+  def create_snapshot
+    @snapshot = ec2.volumes[volume_id].
+      create_snapshot("#{description}")
+    message.info "Created snapshot \"#{snapshot.id}\""
+    return @snapshot
+  end
+
+  # Tags a Snapshot
+  def tag_snapshot
+    snap = snapshot
+    message.info "Tagging snapshot \"#{snap.id}\""
+    tags.map {|key, value|
+      ec2.tags.create(snap, key, {:value => value})
+    }
+  end
+
+  # Purges expired snapshots
+  def purge_backups
+    expired_backups.each do |snap|
+      message.info "Deleting expired snapshot (#{snap.id})"
+      snap.delete
+    end
+  end
+
+  # Creates a list of expired snapshots according to the expiration time
+  # specified in the app's configuration file
+  # @return [Array] An array of expired snapshot objects
+  def expired_backups
+    @expired_backups = []
+    all_backups.each {|snap|
+      if snap.start_time < (Time.now - backup_expiration*24*60*60)
+        @expired_backups.push snap
+      end
+    }
+    return @expired_backups
+  end
+
+  # Check for a an expiration period in the configuration file
+  def backup_expiration
+    expiration = config[:expiration]
+    if expiration.nil?
+      @backup_expiration = 7
+    else
+      @backup_expiration = expiration
+    end
+    return @backup_expiration.to_i
+  end
+
+  # Returns a list of snapshots that are named the same with the current FQDN.
+  def all_backups
+    @all ||= ec2.snapshots.
+      with_owner('self').
+      tagged('Name').tagged_values(fqdn)
+  end
+
+end # class Snapshot
+
+end # module EC2
+end # module VGH
+
+require 'vgh/system'
+require 'vgh/output'
+require 'vgh/configuration'
+require 'vgh/ec2'
+require 'vgh/ec2/metadata'
+require 'vgh/ec2/volume'

data/lib/vgh/ec2/volume.rb

@@ -0,0 +1,77 @@
+module VGH
+module EC2
+
+# Collects information about the EBS volumes attached to the current instance.
+# == Usage
+#     volumes = Volume.new
+#     puts volumes.list
+#     puts volumes.list_tagged('MyTag')
+#
+class Volume
+
+  # Creates an array with the IDs of all the volumes attached to the current
+  # instance
+  # @return [Array]
+  def list
+    @list = []
+    mappings.map {|device, info| @list.push(info.volume.id)}
+    return @list
+  end
+
+  # Creates an array with the IDs of all the volumes attached to the current
+  # instance, that contain a specific tag key
+  # @param [String] tag_key The Tag to look for
+  # @return [Array]
+  def list_tagged(tag_key)
+    @list_tagged = []
+    list.each {|vid|
+      volume_tags(vid).map {|volume_tag|
+        @list_tagged.push(vid) if volume_tag.key == tag_key
+      }
+    }
+    return @list_tagged
+  end
+
+  # Returns a Hash containing the block device mappings of the current instance.
+  # @return [Hash]
+  def mappings
+    message.info "Creating a list of volumes..."
+    @mappings ||= instance.block_device_mappings
+  end
+
+  # The current instance object
+  # @return [Instance] An instance object
+  def instance
+    @instance ||= ec2.instances[instance_id]
+  end
+
+  # Get volume's Name tag
+  # @param [String] volume_id The ID of the volume
+  # @return [String] The tag of the volume or (NOTAG) if a tag does not exists.
+  def name_tag(volume_id)
+    @name_tag = 'NOTAG'
+    volume_tags(volume_id).each {|tag|
+      @name_tag = tag.value if tag.key == 'Name'
+    }
+    return @name_tag
+  end
+
+  # Returns a collection of tags for the specified volume.
+  # @param [String] volume_id The id of the volume to query for tags.
+  # @return [TagsCollection] An array of tag objects
+  def volume_tags(volume_id)
+    @volume_tags = ec2.tags.
+      filter('resource-type', 'volume').
+      filter('resource-id', volume_id)
+  end
+
+end # class Volume
+
+end # module EC2
+end # module VGH
+
+
+require 'vgh/output'
+require 'vgh/configuration'
+require 'vgh/ec2'
+require 'vgh/ec2/metadata'

data/lib/vgh/ec2.rb

@@ -0,0 +1,15 @@
+require 'aws-sdk'
+
+module VGH
+
+  # Creates a global ec2 method.
+  def ec2
+    $ec2 = AWS::EC2.new
+  end
+
+  # EC2 Module
+  module EC2
+  end
+
+end # module VGH
+

data/lib/vgh/output.rb

@@ -99,8 +99,6 @@ END_HEADER
     def footer
       stdout <<END_FOOTER
 
-###############################################################################
-RUBY ROCKS!!!
 ###############################################################################"
 END_FOOTER
     end

data/lib/vgh/system/lvm.rb

@@ -12,70 +12,84 @@ module System
 #
 # == Usage:
 #
-#     lvm = System::LV.new
-#     lvm.suspend_lvs
+#     lvm = System::LVM.new
+#     lvm.suspend
 #     # run the code that takes the snapshot
-#     lvm.resume_lvs
+#     lvm.resume
 #
-class LV
+class LVM
 
   # Loads variables and checks if LVM Tools are installed
   def initialize
-    @dmcmd = '/sbin/dmsetup'
     installed?
   end
 
+  # @return [String] The dmsetup system command
+  def dm_cmd
+    @dmcmd ||= '/sbin/dmsetup'
+  end
+
   # Warn message if LVM tools are not installed
   def installed?
-    message.warn "LVM Tools are not installed" unless File.exists?(@dmcmd)
+    if File.exists?(dm_cmd)
+      return true
+    else
+      message.warn "LVM Tools are not installed"
+      return false
+    end
+  end
+
+  # @return [String] A list of logical volumes present
+  def lvs
+    if ( installed? and System.is_root? )
+      @lvs ||= `#{dm_cmd} ls | /bin/grep -E -v 'swap|root'`
+    else
+      message.warn "Listing logical volume needs root privileges!"
+      return nil
+    end
   end
 
   # Test if logical volumes are present
   # @return [Boolean]
   def lvs_are_present?
-    lvs_are_present = false
-    @lvlist = `#{@dmcmd} ls | /bin/grep -E -v 'swap|root'`
-    if @lvlist != "No devices found\n" then
-      lvs_are_present = true
+    if lvs != "No devices found\n" then
+      return true
+    else
+      message.info "No logical volumes found."
+      return false
     end
-    return lvs_are_present
   end
 
   # Suspend all logical volume
   def suspend
-    if lvs_are_present?
-      suspend_lvs
-    else
-      message.info "No logical volumes found."
-    end
+    suspend_lvs if lvs_are_present?
   end
 
   # The actual suspend action
   def suspend_lvs
-    for lv_name in @lvlist.split[0]
+    for lv_name in lvs.split[0]
       message.info "Suspending Logical Volume '#{lv_name}'..."
-      `#{@dmcmd} suspend #{lv_name}`
+      `#{dm_cmd} suspend #{lv_name}`
     end
   end
 
   # Resume all logical volumes
   def resume
-    if lvs_are_present?
-      resume_lvs
-    end
+    resume_lvs if lvs_are_present?
   end
 
   # The actual resume action
   def resume_lvs
-     for lv_name in @lvlist.split[0]
+    for lv_name in lvs.split[0]
       message.info "Resuming Logical Volume '#{lv_name}'..."
-      `#{@dmcmd} resume #{lv_name}`
+      `#{dm_cmd} resume #{lv_name}`
     end
   end
 
-end # class LV
+end # class LVM
 end # module System
 end # module VGH
 
 require 'vgh/output'
+require 'vgh/system'
 

data/lib/vgh/system/mysql.rb

@@ -16,20 +16,30 @@ class MySQL
 
   # Load defaults
   def initialize
-    cfg         = app_config
     @mysqladmin = '/usr/bin/mysqladmin'
     @mysql      = '/usr/bin/mysql'
-    @user       = cfg[:mysql_user]
-    @password   = cfg[:mysql_pwd]
   end
 
+  # Get MySQL user
+  # @return [String]
+  def mysql_user
+    @mysql_user ||= config[:mysql_user]
+  end
+
+  # Get MySQL password
+  # @return [String]
+  def mysql_password
+    @mysql_password ||= config[:mysql_password]
+  end
+
+
   # Check if server is running and we have the right credentials
   # @return [Boolean]
   def mysql_exists?
     mysql_exists = false
     if File.exists?(@mysqladmin)
       mysql_exists = system "#{@mysqladmin} -s ping"
-      if ! @user and ! @password
+      if ! mysql_user and ! mysql_password
         message.warning 'WARNING: MySQL exists but no credentials were found!'
         mysql_exists = false
       end
@@ -41,7 +51,7 @@ class MySQL
   def flush
     if mysql_exists?
       message.info 'Locking MySQL tables...'
-      `#{@mysql} -u#{@user} -p#{@password} -e "FLUSH TABLES WITH READ LOCK"`
+      `#{@mysql} -u#{mysql_user} -p#{mysql_password} -e "FLUSH TABLES WITH READ LOCK"`
     end
   end
 
@@ -49,7 +59,7 @@ class MySQL
   def unlock
     if mysql_exists?
       message.info 'Unlocking MySQL tables...'
-      `#{@mysql} -u#{@user} -p#{@password} -e "UNLOCK TABLES"`
+      `#{@mysql} -u#{mysql_user} -p#{mysql_password} -e "UNLOCK TABLES"`
     end
   end
 

data/lib/vgh/system.rb

@@ -4,7 +4,7 @@ module VGH
   # the system's one)
   # @return [String]
   def fqdn
-    remote_fqdn = app_config[:fqdn]
+    remote_fqdn = config[:fqdn]
     if remote_fqdn
       $fqdn ||= remote_fqdn
     else
@@ -12,15 +12,6 @@ module VGH
     end
   end
 
-  # Check if the script is run as root
-  # @return [Boolean]
-  def is_root?
-    if Process.uid == 0
-      return true
-    else
-      return false
-    end
-  end
 
   # This is a parent class for different system actions performed by the scripts
   # included in this gem. For more information see the classes defined under
@@ -32,12 +23,61 @@ module VGH
   #
   module System
 
+    # Check if the script is run as root
+    # @return [Boolean]
+    def self.is_root?
+      if Process.uid == 0
+        return true
+      else
+        return false
+      end
+    end
+
     # Returns the current system's FQDN
     # @return [String]
     def self.fqdn
       $fqdn ||= `hostname -f`
     end
 
+    # Returns the current system's FQDN
+    # @return [String]
+    def self.lock
+      unless remotely?
+        mysql.flush
+        lvm.suspend
+      end
+    end
+
+    # Returns the current system's FQDN
+    # @return [String]
+    def self.unlock
+      unless remotely?
+        mysql.unlock
+        lvm.resume
+      end
+    end
+
+    # Checks if this script is run remotely.
+    # @return [Boolean]
+    def self.remotely?
+      cfg = config
+      if cfg[:instance] or cfg[:fqdn]
+        return true
+      else
+        return false
+      end
+    end
+
+    # Initializes the MySQL class
+    def self.mysql
+      mysql ||= System::MySQL.new
+    end
+
+    # Initializes the LVM class
+    def self.lvm
+      lvm ||= System::LVM.new
+    end
+
   end # module System
 
 end # module VGH

data/lib/vgh/version.rb

@@ -1,6 +1,6 @@
 module VGH
   # Version number
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 
   # Returns the version number
   def version

data/lib/vgh.rb

@@ -28,6 +28,8 @@ module VGH
     case app
     when 'ec2-backup'
       APPS::EC2_Backup.new.run
+    when 'checkpoint'
+      APPS::Checkpoint.new.run
     end
 
     # Display footer
@@ -48,6 +50,6 @@ module VGH
 end # module VGH
 
 require "vgh/output"
-require "vgh/system"
 require "vgh/apps"
 require "vgh/apps/ec2_backup"
+require "vgh/apps/checkpoint"

data/spec/cli_spec.rb

@@ -11,34 +11,26 @@ describe VGH::CLI do
     ARGV[0] = app
   end
 
-  it "Should get the app name as the first argument" do
-      VGH::CLI.new.options[:app].should eq app
-    end
-
-  context "When '-v' passed to the command line" do
-    it "Verbosity should be enabled" do
-      ARGV.push('-v')
-      VGH::CLI.new.options[:verbose].should be_true
-    end
+  it 'Should get the app name as the first argument' do
+      subject.options[:app].should eq app
   end
 
-  context "When '-v' NOT passed to the command line" do
-    it "Verbosity should be disabled" do
-      VGH::CLI.new.options[:verbose].should be_false
-    end
+  it 'Verbosity' do
+    subject.options[:verbose].should be_false
   end
 
-  context "When '-l' passed to the command line" do
-    it "Logging should be enabled" do
-      ARGV.push('-l')
-      VGH::CLI.new.options[:logging].should be_true
-    end
+  it 'No Verbosity' do
+    ARGV.push('--verbose')
+    subject.options[:verbose].should be_true
   end
 
-  context "When '-l' NOT passed to the command line" do
-    it "Logging should be disabled" do
-      VGH::CLI.new.options[:logging].should be_false
-    end
+  it 'Logging' do
+    ARGV.push('--logging')
+    subject.options[:logging].should be_true
+  end
+
+  it 'No Logging' do
+    subject.options[:logging].should be_false
   end
 
 end

data/spec/configuration_spec.rb

@@ -0,0 +1,44 @@
+require 'helpers/spec'
+require 'vgh'
+require 'vgh/configuration'
+
+describe VGH::Configuration do
+
+  let(:configuration) {VGH::Configuration.allocate}
+  let(:cli_confdir) {'/tmp'}
+  let(:config_hash) {"---
+:key1: 'value1'
+:key2: 'value2'"}
+
+  before(:each) do
+    configuration.stub(:cli).and_return({:confdir => nil})
+  end
+
+  it 'Should return the default config directory' do
+    configuration.global_config_dir.should eq('/etc/vgh')
+  end
+
+  it 'Should return the user config directory' do
+    configuration.user_config_dir =~ /.*\.vgh$/
+  end
+
+  it 'Should return a config directory from cli or return users directory' do
+    configuration.confdir.should =~ /.*\.vgh/
+    configuration.stub(:cli).and_return({:confdir => cli_confdir})
+    configuration.confdir.should eq(cli_confdir)
+  end
+
+  it 'Should return the main configuration file' do
+    configuration.config_file.should =~ /.*\.vgh\/config\.yml/
+  end
+
+  it 'Should initialize clean' do
+    cfg = VGH::Configuration
+    [:message, :cli, :log, :aws_config].each {|s|
+      cfg.any_instance.stub(s).and_return(Dummy.new)
+    }
+    cfg.any_instance.stub(:validate).and_return(config_hash)
+    subject.config.should eq(config_hash)
+  end
+
+end

data/spec/ec2/metadata_spec.rb

@@ -0,0 +1,14 @@
+require 'helpers/spec'
+require 'vgh/ec2/metadata'
+
+describe VGH::EC2::MetaData do
+
+  let(:response) {'Remote server response'}
+  it 'Should receive valid response from the AWS metadata server' do
+    subject.stub_chain(:open, :read).and_return(response)
+    subject.instance_id.should eq(response)
+    subject.root_device.should eq(response)
+  end
+
+end
+

data/spec/ec2/snapshot_spec.rb

@@ -0,0 +1,39 @@
+require 'helpers/spec'
+require 'aws-sdk'
+require 'vgh/ec2/snapshot'
+require 'vgh/system'
+
+describe VGH::EC2::Snapshot do
+
+  include_context 'AWS Dummy'
+  let(:snap) {VGH::EC2::Snapshot.allocate}
+
+  before(:each) do
+    snap.stub(:snapshot).and_return(@snapshot)
+    snap.stub(:message).and_return(Dummy.new)
+    snap.stub(:tags).and_return(@tag_hash)
+    snap.stub(:ec2).and_return(@ec2)
+    snap.stub(:fqdn).and_return(@fqdn)
+  end
+
+  it "Should tag a snapshot" do
+    snap.tag_snapshot.each{|t|
+      t.should be_a AWS::EC2::Tag
+    }
+  end
+
+  it "Should list all snapshots" do
+    snap.all_backups.should be_an AWS::EC2::SnapshotCollection
+  end
+
+  it "Should create a list of expired backups" do
+    snap.expired_backups.should be_an Array
+  end
+
+  it "Should return a backup expiration integer" do
+    snap.stub(:config).and_return({:expiration => 5})
+    snap.backup_expiration.should eq(5)
+  end
+
+end
+

data/spec/ec2/volume_spec.rb

@@ -0,0 +1,47 @@
+require 'helpers/spec'
+
+require 'aws-sdk'
+require 'vgh/ec2/volume'
+
+describe VGH::EC2::Volume do
+
+  include_context 'AWS Dummy'
+
+  let(:volume) {VGH::EC2::Volume.new}
+
+  before(:each) do
+    volume.stub(:message).and_return(Dummy.new)
+    volume.stub(:ec2).and_return(@ec2)
+  end
+
+  it "Should return an instance" do
+    volume.stub(:instance_id).and_return(@instance.id)
+    volume.instance.should be_a(AWS::EC2::Instance)
+  end
+
+  it "Should create a hash with block device mappings" do
+    volume.stub_chain(:instance, :block_device_mappings).
+      and_return(@instance_mappings)
+    volume.mappings.should be_a_kind_of Hash
+  end
+
+  it "Should return a collection of volume tags" do
+    volume.volume_tags(@volume2.id).should be_a(@tag_collection)
+  end
+
+  it "Should return the value of the name tag or (NOTAG)" do
+    volume.name_tag(@volume1.id).should be_a String
+  end
+
+  it "Should create a list of volumes" do
+    volume.stub(:mappings).and_return(@instance_mappings)
+    volume.list.should be_a Array
+  end
+
+  it "Should return a list of volumes that need a checkpoint" do
+    volume.stub(:list).and_return([])
+    volume.list_tagged('CHECKPOINT').should be_a Array
+  end
+
+end
+