vgh 0.0.1

data/lib/vgh/extended_aws/extended_ec2/metadata.rb

@@ -0,0 +1,46 @@
+require 'open-uri'
+require 'net/http'
+require 'uri'
+
+module VGH
+module Extended_AWS
+module Extended_EC2
+
+# This class gathers metadata information about the current instance, used by
+# the applications in this gem.
+#
+# == Usage
+#
+#     data = Metadata.new
+#     id   = data.instance_id
+#     root = data.root_device
+#
+class MetaData
+
+  # Query the API server for the instance ID
+  # @return [String, nil] The current instance's ID
+  def instance_id
+    begin
+      @instance_id = open('http://instance-data/latest/meta-data/instance-id').read
+    rescue
+      message.fatal 'Could not get Instance ID!'
+    end
+  end
+
+  # Query the API server for the root device
+  # @return [String, nil] The root device of the current instance
+  def root_device
+    begin
+      @root_device = open('http://instance-data/latest/meta-data/block-device-mapping/root').read
+    rescue
+      message.fatal 'Could not get the root device!'
+    end
+  end
+
+end
+
+end # module Extended_EC2
+end # module Extended_AWS
+end # module VGH
+
+require 'vgh/output'

data/lib/vgh/extended_aws/extended_ec2/snapshot.rb

@@ -0,0 +1,90 @@
+module VGH
+module Extended_AWS
+module Extended_EC2
+
+# Creates a snapshot of the specified volume.
+#
+# == Usage
+#
+#     snap = Snapshot.new.
+#     snap.create(id, tag)
+#
+class Snapshot
+
+  # Load all needed classes
+  def initialize
+    @instance_id = MetaData.new.instance_id
+    @fqdn        = System.fqdn
+  end
+
+  # The workflow to create a snapshot:
+  # - create snapshot
+  # - add a name tag
+  # - add an info tag
+  # @param [String] volume_id The ID of the volume to snapshot
+  # @param [String] volume_tag The Tag of the volume to snapshot
+  def create(volume_id, volume_tag)
+    snapshot(volume_id, volume_tag)
+    name_tag
+    info_tag(volume_id)
+    message.info "Creating and tagging snapshot \"#{@snapshot.id}\""
+  end
+
+  # Creates a snapshot for the specified volume
+  # @param [String] volume_id The ID of the volume to snapshot
+  # @param [String] volume_tag The tag of the volume to snapshot
+  # @return [String, nil] The newly created snapshot object
+  def snapshot(volume_id, volume_tag)
+    @snapshot = ec2.volumes[volume_id].
+      create_snapshot("Backup for #{volume_id}(#{volume_tag})")
+  end
+
+  # Creates a name tag for the newly created snapshot.
+  # The name is the FQDN of the current instance.
+  def name_tag
+    ec2.snapshots[@snapshot.id].tag('Name', :value => @fqdn)
+  end
+
+  # Creates an info tag for the newly created snapshot
+  def info_tag(volume_id)
+    ec2.snapshots[@snapshot.id].tag("Backup_#{@instance_id}", :value => volume_id)
+  end
+
+  # Purges expired snapshots
+  def purge
+    expired.each do |snapshot|
+      message.info "Deleting expired snapshot (#{snapshot.id})"
+      snapshot.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
+    @expired = []
+    all.each {|snapshot|
+      if snapshot.start_time < (Time.now - $cfg[:expiration]*24*60*60)
+        @expired.push snapshot
+      end
+    }
+    return @expired
+  end
+
+  # Returns a list of snapshots that are named the same with the current FQDN.
+  def all
+    @all ||= ec2.snapshots.
+      with_owner('self').
+      tagged('Name').tagged_values(@fqdn)
+  end
+
+end # class Snapshot
+
+end # module Extended_EC2
+end # module Extended_AWS
+end # module VGH
+
+require 'vgh/system'
+require 'vgh/output'
+require 'vgh/configuration'
+require 'vgh/extended_aws/extended_ec2/metadata'

data/lib/vgh/extended_aws/extended_ec2/volume.rb

@@ -0,0 +1,66 @@
+module VGH
+module Extended_AWS
+module Extended_EC2
+
+# Collects information about the EBS volumes attached to the current instance.
+# == Usage
+#     @volume = Volume.new
+#     @volume.list.map {|id, info|
+#       puts id
+#       puts info[:tag]
+#       puts info[:device)
+#     }
+#
+class Volume
+
+  # Collects all needed variables
+  def initialize
+    @instance_id = MetaData.new.instance_id
+  end
+
+  # Creates a Hash collection of volumes containing their id, tag and device
+  # @return [Hash]
+  def list
+    @list = {}
+    mappings.map {|device, info|
+      volume_id = info.volume.id
+      @list[volume_id] = {
+        :device => device,
+        :tag => tag(volume_id)
+      }
+    }
+    return @list
+  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 ||= ec2.instances[@instance_id].block_device_mappings
+  end
+
+  # Get volume's Name tag
+  # @return [String] The tag of the volume or (NOTAG) if a tag does not exists.
+  def tag(volume_id)
+    v_tags = tags(volume_id)
+    v_tags.count == 0 ? @tag = '(NOTAG)' : @tag = v_tags.first.value
+  end
+
+  # Returns a collection of tags for the specified volume.
+  # @param [String] volume_id The id of the volume to query for tags.
+  def tags(volume_id)
+    @tags = ec2.tags.
+      filter('resource-type', 'volume').
+      filter('key', 'Name').
+      filter('resource-id', volume_id)
+  end
+
+end # class Volume
+
+end # module Extended_EC2
+end # module Extended_AWS
+end # module VGH
+
+require 'vgh/output'
+require 'vgh/configuration'
+require 'vgh/extended_aws/extended_ec2/metadata'

data/lib/vgh/extended_aws/extended_ec2.rb

@@ -0,0 +1,10 @@
+module VGH
+module Extended_AWS
+
+# A collection of classes used with the AWS-SDK for Ruby (EC2).
+module Extended_EC2
+
+end
+
+end # module Extended_AWS
+end # module VGH

data/lib/vgh/extended_aws.rb

@@ -0,0 +1,10 @@
+require 'aws-sdk'
+
+module VGH
+
+  # A collection of classes used with the AWS-SDK for Ruby.
+  module Extended_AWS
+
+  end # module Extended_AWS
+
+end # module VGH

data/lib/vgh/logging.rb

@@ -0,0 +1,66 @@
+require 'logger'
+
+module VGH
+
+  # Returns log state
+  def log
+    if logging?
+      $log ||= Logging.new.log
+    else
+      $log ||= Logger.new('/dev/null')
+    end
+  end
+
+  # == Description:
+  #
+  # This class logs messages if logging is enabled from the command line
+  # options. The default location of the log files is +/var/log/vgh.log+.
+  #
+  # This class uses the Ruby Logger standard library.
+  #
+  #
+  # == Usage:
+  #
+  #     log = Logging.new.log
+  #     log.info "This is an info message"
+  #
+  class Logging
+
+    # Defaults
+    def defaults
+      @path  = '/var/log/vgh.log'
+      @level = Logger::INFO
+    end
+
+    # Check log file existence
+    def initialize
+      defaults
+      validate_log_directory
+    end
+
+    # Creates a log directory and file if it does not already exist
+    def validate_log_directory
+      dir = File.dirname(@path)
+      Dir.mkdir(dir) unless File.exists?(dir)
+    end
+
+    # Opens the log file
+    def log_file
+      File.open(@path, File::WRONLY | File::APPEND | File::CREAT)
+    end
+
+    # Global, memoized, lazy initialized instance of a logger
+    def log
+      # Logger
+      @log ||= Logger.new(log_file)
+      @log.level = @level
+      @log.datetime_format = "%Y-%m-%d %H:%M "  # simplify time output
+      @log
+    end
+
+  end # class Logging
+
+end # module VGH
+
+require 'vgh/cli'
+

data/lib/vgh/output.rb

@@ -0,0 +1,113 @@
+module VGH
+
+  # Creates a global message method
+  def message
+    $message ||= Output.new
+  end
+
+  # == Description:
+  #
+  # This class sends messages to +STDOUT+ or to a log file. It takes the following
+  # standard methods:
+  # - +debug+
+  # - +info+
+  # - +warn+
+  # - +error+
+  # - +fatal+
+  #
+  # If +stdout+ is called then the message is only sent to +STDOUT+.
+  #
+  # If +header+ or +footer+ is called then it displays them.
+  #
+  #
+  # == Usage:
+  #     # Load output
+  #     message = Output.new
+  #
+  #     message.header
+  #
+  #     message.info "Starting code"
+  #     # Your code here
+  #     message.info "End code"
+  #
+  #     message.footer
+  #
+  class Output
+
+    # Debug message
+    attr_reader :debug
+    # Inforational message
+    attr_reader :info
+    # Warning message
+    attr_reader :warn
+    # Error message
+    attr_reader :error
+    # Fatal Error message
+    attr_reader :fatal
+    # Header
+    attr_reader :header
+    # Footer
+    attr_reader :footer
+
+    # Writes a debug log message and outputs to screen
+    def debug(message)
+      log.debug(message)
+      stdout message
+    end
+
+    # Writes an info log message and outputs to screen
+    def info(message)
+      log.info(message)
+      stdout message
+    end
+
+    # Writes an warn log message and outputs to screen
+    def warn(message)
+      log.warn(message)
+      stdout message
+    end
+
+    # Writes an error log message and outputs to screen
+    def error(message)
+      log.error(message)
+      stdout message
+    end
+
+    # Writes a fatal log message and outputs to screen
+    def fatal(message)
+      log.fatal(message)
+      stdout message
+    end
+
+    # Outputs a message to screen
+    def stdout(message)
+      puts message if verbose?
+    end
+
+    # Returns the header
+    def header
+     stdout <<END_HEADER
+###############################################################################
+VladGh.com - Scripts (v#{VERSION})
+#{Time.now.strftime("%m/%d/%Y %H:%M:%S(%Z)")}
+###############################################################################
+
+END_HEADER
+    end
+
+    # Returns the footer
+    def footer
+      stdout <<END_FOOTER
+
+###############################################################################
+RUBY ROCKS!!!
+###############################################################################"
+END_FOOTER
+    end
+
+  end # class Output
+end # module VGH
+
+require 'vgh/cli'
+require 'vgh/configuration'
+require 'vgh/logging'

data/lib/vgh/system/lvm.rb

@@ -0,0 +1,81 @@
+module VGH
+module System
+
+# This class is able to suspend or resume logical volumes. The +lvm2+ package
+# needs to be installed for this to work.
+#
+# Suspending a volume becomes useful if you want for example a consistent
+# EC2 snapshot of it. Any I/O that has already been mapped by the device but
+# has not yet completed will be flushed. Any further I/O to that device will
+# be postponed for as long as the device is suspended.
+#
+#
+# == Usage:
+#
+#     lvm = System::LV.new
+#     lvm.suspend_lvs
+#     # run the code that takes the snapshot
+#     lvm.resume_lvs
+#
+class LV
+
+  # Loads variables and checks if LVM Tools are installed
+  def initialize
+    @dmcmd = '/sbin/dmsetup'
+    installed?
+  end
+
+  # Warn message if LVM tools are not installed
+  def installed?
+    message.warn "LVM Tools are not installed" unless File.exists?(@dmcmd)
+  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
+    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
+  end
+
+  # The actual suspend action
+  def suspend_lvs
+    for lv_name in @lvlist.split[0]
+      message.info "Suspending Logical Volume '#{lv_name}'..."
+      `#{@dmcmd} suspend #{lv_name}`
+    end
+  end
+
+  # Resume all logical volumes
+  def resume
+    if lvs_are_present?
+      resume_lvs
+    end
+  end
+
+  # The actual resume action
+  def resume_lvs
+     for lv_name in @lvlist.split[0]
+      message.info "Resuming Logical Volume '#{lv_name}'..."
+      `#{@dmcmd} resume #{lv_name}`
+    end
+  end
+
+end # class LV
+end # module System
+end # module VGH
+
+require 'vgh/output'
+

data/lib/vgh/system/mysql.rb

@@ -0,0 +1,56 @@
+module VGH
+module System
+
+# This class checks if a local MySQL server is present and running.
+# The credentials need to be specified in the app's configuration file.
+#
+#
+# == Usage
+#
+#     mysql = MySQL.new
+#     mysql.flush
+#     # run backup
+#     mysql.unlock
+#
+class MySQL
+
+  # Load defaults
+  def initialize
+    @mysqladmin = '/usr/bin/mysqladmin'
+    @mysql      = '/usr/bin/mysql'
+    @user       = $cfg[:mysql_user]
+    @password   = $cfg[:mysql_pwd]
+  end
+
+  # Check if server is running and we have access to the credentials file
+  # @return [Boolean]
+  def mysql_exists?
+    mysql_exists = false
+    if File.exists?(@mysqladmin)
+      mysql_exists = system "#{@mysqladmin} -s ping"
+    end
+    return mysql_exists
+  end
+
+  # Lock & Flush the MySQL tables
+  def flush
+    if mysql_exists?
+      message.info 'Locking MySQL tables...'
+      `#{@mysql} -u#{@user} -p#{@password} -e "FLUSH TABLES WITH READ LOCK"`
+    end
+  end
+
+  # Unlock the MySQL tables
+  def unlock
+    if mysql_exists?
+      message.info 'Unlocking MySQL tables...'
+      `#{@mysql} -u#{@user} -p#{@password} -e "UNLOCK TABLES"`
+    end
+  end
+
+end # class MySQL
+end # module System
+end # module VGH
+
+require 'vgh/output'
+require 'vgh/configuration'

data/lib/vgh/system.rb

@@ -0,0 +1,21 @@
+module VGH
+
+  # 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
+  # this namespace.
+  #
+  # == Usage
+  #
+  #     fqdn = System.fqdn
+  #
+  module System
+
+    # FQDN
+    # @return [String] The FQDN of the current machine.
+    def self.fqdn
+      $fqdn ||= `hostname -f`
+    end
+
+  end # module System
+
+end # module VGH

data/lib/vgh/version.rb

@@ -0,0 +1,9 @@
+module VGH
+  # Version number
+  VERSION = "0.0.1"
+
+  # Returns the version number
+  def version
+    VERSION
+  end
+end

data/lib/vgh.rb

@@ -0,0 +1,60 @@
+# Try to load rubygems.  Hey rubygems, I hate you.
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+require 'aws-sdk'
+require 'sinatra'
+
+require 'yaml'
+require 'logger'
+require 'erb'
+require 'open-uri'
+require 'net/http'
+require 'uri'
+require 'optparse'
+
+# See the {file:README.rdoc README} file.
+module VGH
+
+  # The main run method
+  def run
+
+    # Check if this script is run with root credentials
+    root_check
+
+    # Display header
+    show_header
+
+    # Run apps
+    case app
+    when 'ec2-backup'
+      APPS::EC2_Backup.new.run
+    end
+
+    # Display footer
+    show_footer
+
+  end # end run method
+
+  # Returns the header
+  def show_header
+    message.header
+  end
+
+  # Returns the footer
+  def show_footer
+    message.footer
+  end
+
+  # Raise error if this app is not run as root
+  def root_check
+    raise 'Must run as root' unless Process.uid == 0
+  end
+
+end # module VGH
+
+require "vgh/output"
+require "vgh/apps"
+require "vgh/apps/ec2_backup"

data/spec/cli_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'vgh'
+require 'vgh/apps'
+require 'vgh/cli'
+
+describe "Command Line" do
+  VGH::APPS.list.map {|app_name|
+    it "Should accept '#{app_name}' as the first argument" do
+      ARGV[0] = app_name
+      VGH::CLI.new.options[:app].should eq app_name
+    end
+  }
+
+  it "Should enable verbosity" do
+    ARGV[0] = VGH::APPS.list.shuffle.first
+    ARGV.push('-v')
+    VGH::CLI.new.options[:verbose].should be_true
+  end
+
+  it "Should enable logging" do
+    ARGV[0] = VGH::APPS.list.shuffle.first
+    ARGV.push('-l')
+    VGH::CLI.new.options[:logging].should be_true
+  end
+end

data/spec/misc_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'vgh'
+require 'vgh/cli'
+require 'vgh/apps'
+require 'vgh/output'
+require 'vgh/logging'
+require 'vgh/configuration'
+
+describe "Various Tests" do
+  it "Should have an array of supported apps" do
+    VGH::APPS.list.should be_an Array
+  end
+
+  it "Should write logs" do
+    log = VGH::Logging.new.log
+    log.should_receive(:info).with("RSpec Test")
+    log.info("RSpec Test")
+  end
+
+  it "Should write messages" do
+    message = VGH::Output.new
+    message.should_receive(:stdout).with("RSpec Test")
+    message.stdout("RSpec Test")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end
+