reptile 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-06-24
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,20 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+bin/replication_status
+lib/reptile.rb
+lib/reptile/databases.rb
+lib/reptile/delta_monitor.rb
+lib/reptile/dtd.sql
+lib/reptile/heartbeat.rb
+lib/reptile/replication_monitor.rb
+lib/reptile/runner.rb
+lib/reptile/status.rb
+lib/reptile/users.rb
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_reptile.rb

data/PostInstall.txt

@@ -0,0 +1,5 @@
+
+For more information on reptile, see http://reptile.rubyforge.org
+
+
+

data/README.rdoc

@@ -0,0 +1,36 @@
+= reptile
+
+Reptile is an easy to use utility that will monitor your MySQL replication, so you can forget about it and focus on the good stuff.  It provides a utility for generate replication reports, and can email if replication appears to be failing.
+
+== REQUIREMENTS:
+
+A mysql replication setup.
+
+== INSTALL:
+
+sudo gem install reptile
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Nick Stielau
+
+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/Rakefile

@@ -0,0 +1,38 @@
+require 'rubygems' unless ENV['NO_RUBYGEMS']
+%w[rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/reptile'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('reptile', Reptile::VERSION) do |p|
+  p.developer('FIXME full name', 'FIXME email')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt'
+  p.rubyforge_name       = p.name
+  p.bin_files            = ["bin/replication_status"]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+desc "Upload current documentation to Rubyforge"
+task :upload_docs => [:redocs] do
+  sh "scp -r doc/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/doc/"
+end
+
+desc "Upload current documentation to Rubyforge"
+task :upload_site do
+  #webgen && scp -r output/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/
+  sh "scp -r site/* nstielau@rubyforge.org:/var/www/gforge-projects/reptile/"
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/bin/replication_status

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'reptile'
+
+commands = []
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [path_to_config_file]"
+
+  opts.on("-h", "--help", "Displays this help info") do
+    puts opts
+    exit 0
+  end
+  
+  opts.on("-s", "--status", "Displays the slave status") do
+    commands << 'check_slaves'
+  end
+  
+  opts.on("-d", "--diff", "Checks the row count difference between master and slave") do
+    commands << 'diff_tables'
+  end
+  
+  opts.on("-r", "--report", "Sends a report email") do
+    commands << 'report'
+  end
+  
+  opts.on("-b", "--heartbeat", "Checks the heartbeat timestamp difference between master and slave") do
+    commands << 'heartbeat'
+  end
+  
+  opts.on("-x", "--stop_slaves", "Stops all slaves") do
+    commands << 'stop_slaves'
+  end
+  
+  opts.on("-g", "--start_slaves", "Starts all slaves") do
+    commands << 'start_slaves'
+  end
+
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::ParseError => e
+    warn e.message
+    puts opts
+    exit 1
+  end
+end
+
+config_file = 'replication.yml'
+
+if ARGV.empty? && !File.exists?(config_file)
+  abort "Please specify the directory containing the '#{config_file}' file, e.g. `#{File.basename($0)} ~/repl'"
+elsif !ARGV.empty? && !File.exists?(ARGV.first)
+  abort "`#{ARGV.first}' does not exist."
+elsif !ARGV.empty? && !File.directory?(ARGV.first)
+  abort "`#{ARGV.first}' is not a directory."
+elsif !ARGV.empty? && ARGV.length > 1
+  abort "Too many arguments; please specify only the directory to #{File.basename($0)}."
+end
+
+Reptile::ReplicationMonitor.load_config_file(ARGV.first.nil? ? config_file : "#{ARGV.first}/#{config_file}")
+
+if (commands.include?('start_slaves') || commands.include?('stop_slaves'))
+  Reptile::Runner.send(commands[0]) 
+else
+  (commands.empty? ? ['check_slaves', 'heartbeat', 'diff_tables'] : commands).each do |command|
+    Reptile::ReplicationMonitor.send(command)
+  end
+end

data/lib/reptile/databases.rb

@@ -0,0 +1,51 @@
+module Reptile
+  # The Databases class stores information about different databases, including the config settings
+  # for the master and slave of each particular database.
+  class Databases
+    attr :databases
+    
+    def initialize(databases)
+      @databases = databases
+    end
+    
+    # returns an array of the master names
+    def masters
+      @master_configs ||= get_masters
+    end
+
+    # returns an array of the slave names
+    def slaves
+      @slave_configs ||= get_slaves
+    end
+    
+private
+
+    def get_masters
+      masters = databases.dup
+      masters.each_key{|key| masters.delete(key) if masters[key]['master'].nil? }
+      masters.each_key{|key| masters[key] = masters[key]['master'] }
+      masters
+    end
+    
+    # TODO: make private
+    def get_slaves
+      dbs = databases.dup
+      dbs.each_key{|name| dbs.delete(key) if dbs[name]['slave'].nil? }
+      dbs.each_key{|name| dbs[name] = dbs[name]['slave'] }
+      slaves = dbs
+    end
+    
+    # Tries to establish a database connection, and returns that connection.  
+    # Dumps configs on error
+    def self.connect(configs)
+      ActiveRecord::Base.establish_connection(configs)
+      ActiveRecord::Base.connection
+    rescue Exception => e
+      puts "****"
+      puts "Error connecting to database: #{e}"
+      puts "****"
+      puts YAML::dump(configs)
+      exit 1
+    end
+  end
+end

data/lib/reptile/delta_monitor.rb

@@ -0,0 +1,86 @@
+module Reptile
+  # This monitor compares the row counts for each table for each master and slave.  
+  class DeltaMonitor
+    # Set the user settings for a user that has global SELECT privilidgess
+    def self.user=(user_settings)
+      @user = user_settings
+    end
+
+    # The user settings for a user that has global select privilidgess
+    def self.user
+      raise "You need to specify a user!" if @user.nil?
+      @user
+    end
+  
+    def self.open_log()
+      logFile = 'db_delta.log'
+      @logFileObj = File.open(logFile, "a")
+    end
+  
+    def self.log(msg)
+      open_log if @logFileObj.nil?
+      puts msg
+      @logFileObj.puts msg
+    end
+  
+    # Retrieve the active database connection.  Nil of none exists.
+    def self.connection
+      ActiveRecord::Base.connection
+    end
+  
+    # Compares the row counts for master tables and slave tables
+    # Returns a hash of TABLE_NAME => ROW COUNT DELTAs
+    def self.diff(db_name, master_configs, slave_configs)
+      ActiveRecord::Base.establish_connection(slave_configs.merge(user))
+      slave_counts = get_table_counts
+
+      ActiveRecord::Base.establish_connection(master_configs.merge(user))
+      master_counts = get_table_counts
+
+      deltas= {}
+      master_counts.each do |table, master_count|    
+        delta = master_count.first.to_i - slave_counts[table].first.to_i
+        deltas[table] = delta
+      end
+    
+      print_deltas(db_name, deltas, master_configs)
+    
+      deltas
+    end
+    
+    # Prints stats about the differences in number of rows between the master and slave
+    def self.print_deltas(db_name, deltas, configs)
+      non_zero_deltas = deltas.select{|table, delta| not delta.zero?}
+      if non_zero_deltas.size.zero?
+        log "Replication counts A-OK for #{db_name} on #{configs['host']} @ #{Time.now}"
+      else
+        log "Replication Row Count Deltas for #{db_name} on #{configs['host']} @ #{Time.now}"
+        log "There #{non_zero_deltas.size > 1 ? 'are' : 'is'} #{non_zero_deltas.size} #{non_zero_deltas.size > 1 ? 'deltas' : 'delta'}"
+        non_zero_deltas.each do |table, delta|
+          log "  #{table} table: #{delta}" unless delta.zero?
+        end
+      end
+    end
+
+    # Returns an array of strings containing the table names
+    # for the current database.
+    def self.get_tables
+      tables = []
+      connection.execute('SHOW TABLES').each { |row| tables << row }
+      tables
+    end
+  
+    # Returns a hash of TABLE_NAME => # Rows for all tables in current db
+    def self.get_table_counts
+      tables = get_tables
+
+      tables_w_count = {}
+      tables.each do |table|
+        connection.execute("SELECT COUNT(*) FROM #{table}").each do |table_count|
+          tables_w_count["#{table}"] = table_count
+        end
+      end
+      tables_w_count
+    end
+  end
+end

data/lib/reptile/dtd.sql

@@ -0,0 +1,18 @@
+// Replace 'REPLICATION_USER', 'MONITORING_BOX', 'REPLICATION_PASS', 'READ_ONLY_PASS', 'READ_ONLY_USER', 'HEARTBEAT_USER' and 'HEARTBEAT_PASS', then execute this SQL as root on the master, slave, and monitoring server
+
+GRANT REPLICATION SLAVE, REPLICATION CLIENT, SUPER ON *.* TO 'REPLICATION_USER'@"localhost" IDENTIFIED BY 'REPLICATION_PASS';
+GRANT REPLICATION SLAVE, REPLICATION CLIENT, SUPER ON *.* TO 'REPLICATION_USER'@"MONITORING_BOX" IDENTIFIED BY 'REPLICATION_PASS';
+
+GRANT SELECT, REPLICATION CLIENT ON *.* TO 'READ_ONLY_USER'@"localhost" IDENTIFIED BY 'READ_ONLY_PASS';
+GRANT SELECT, REPLICATION CLIENT ON *.* TO 'READ_ONLY_USER'@"MONITORING_BOX" IDENTIFIED BY 'READ_ONLY_PASS';
+
+GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'HEARTBEAT_USER'@"localhost" IDENTIFIED BY 'HEARTBEAT_PASS';
+GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'HEARTBEAT_USER'@"MONITORING_BOX" IDENTIFIED BY 'HEARTBEAT_PASS';
+
+CREATE DATABASE replication_monitor;
+
+CREATE TABLE replication_monitor.heartbeats (
+  unix_time INTEGER NOT NULL, 
+  db_time TIMESTAMP NOT NULL, 
+  INDEX time_idx(unix_time)
+)

data/lib/reptile/heartbeat.rb

@@ -0,0 +1,99 @@
+require 'active_record'
+
+module Reptile
+  # MySQL DTD for setting up Heartbeats.  Change HEARTBEAT_USER, HEARTBEAT_PASS, and MONITORING_BOX 
+  # to ip of the monitoring server. 
+  #
+  # GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* 
+  # TO 'HEARTBEAT_USER'@"localhost" IDENTIFIED BY 'HEARTBEAT_PASS';  GRANT SELECT, INSERT, UPDATE,
+  # ALTER ON replication_monitor.* TO 'HEARTBEAT_USER'@"MONITORING_BOX" IDENTIFIED BY 'HEARTBEAT_PASS';
+  # 
+  # CREATE DATABASE replication_monitor;
+  # 
+  # CREATE TABLE replication_monitor.heartbeats (
+  #   unix_time INTEGER NOT NULL, 
+  #   db_time TIMESTAMP NOT NULL, 
+  #   INDEX time_idx(unix_time)
+  # )
+  #
+  class Heartbeat < ActiveRecord::Base
+
+    # Set the default connection settings for writing/reading heartbeats.
+    # These will be merged with the per-database settings passed to <code>connect</code>.
+    def self.user=(default_configs)
+      @user = default_configs
+    end
+  
+    # The default connection settings which override per-database settings.
+    def self.user
+      @user ||= {}
+    end
+  
+    # Merge the connection settings in the configs parameter with HeartBeat defaults. 
+    def self.connect(configs)
+      ReplicationMonitor.connect(configs.merge(user))
+    end
+  
+    # Write a heartbeat.
+    # Thump thump.
+    def self.write(name, configs)
+      connect(configs)
+      heartbeat = Heartbeat.create(:unix_time => Time.now.to_i, :db_time => "NOW()")
+      log "Wrote heartbeat to #{name} at #{Time.at(heartbeat.unix_time)}"
+    end
+
+    # Read the most recent heartbeat and return the delay in seconds, or nil if no heartbeat are found.
+    def self.read(name, configs)
+      connect(configs)
+    
+      current_time = Time.now
+
+      delay = nil
+      heartbeat = Heartbeat.find(:first, :order => 'db_time DESC')
+    
+       # No heartbeats at all!
+      if heartbeat.nil?
+        log "No heartbeats found on #{name} at #{Time.now}"
+        return nil;
+      end
+   
+      # Not sure why we have both, (one is easier to read?).
+      # Use one or the other to calculate delay...
+      delay = (Time.now - Time.at(heartbeat.unix_time)).round
+      #delay = (Time.now - heartbeat.db_time)
+
+      log "Read heartbeat from #{name} at #{Time.at(heartbeat.unix_time)}. The delay is #{strfdelay(delay)}"
+    
+      delay
+    end
+   
+private
+   
+    # Open the 'heartbeat.log' file.
+    def self.open_log
+      logFile = 'heartbeat.log'
+      @logFileObj = File.open(logFile, "a")
+    end
+  
+    # Log a message, both to the file and standard out.
+    def self.log(msg)
+      open_log if @logFileObj.nil?
+      puts msg
+      @logFileObj.puts msg
+    end
+    
+    # Format the delay (in seconds) as a human-readable string.
+    def self.strfdelay(delay)
+      seconds = delay % 60
+      minutes = delay / 60 % 60
+      hours = delay / 60 / 60
+      delay_str = ""
+      delay_str << "#{hours} hours" if hours > 0
+      delay_str << " " if !hours.zero? && (minutes > 0 || seconds > 0)
+      delay_str << "#{minutes} minutes" if minutes > 0
+      delay_str << " " if (!minutes.zero? || !hours.zero?) && seconds > 0
+      delay_str << "#{seconds} seconds" unless seconds.zero?
+      delay_str
+    end
+  end
+end

data/lib/reptile/replication_monitor.rb

@@ -0,0 +1,224 @@
+module Reptile
+  class ReplicationMonitor
+    # Attempts to load the replication.yml configuration file.
+    def self.load_config_file(databases_file)
+      @databases_file = databases_file
+      yaml = YAML::load(File.read(@databases_file))
+      @configs = yaml.delete('config')
+      @users = Users.new(yaml.delete('users'))
+      @databases = Databases.new(yaml)
+      
+      Heartbeat.user = users.heartbeat_user
+      Runner.user = users.replication_user
+      Status.user = users.replication_user
+      DeltaMonitor.user = users.ro_user
+      Runner.databases = databases
+      
+      raise "Please specify a delay theshold 'delay_threshold_secs: 360'" if @configs['delay_threshold_secs'].nil?
+      raise "Please specify a row delta theshold 'row_difference_threshold: 10'" if @configs['row_difference_threshold'].nil?
+      
+    rescue Errno::EACCES => e
+      puts "Unable to open config file: Permission Denied"
+    end
+    
+    # Returns the configs from the replication.yml file
+    def self.configs
+      @configs
+    end
+   
+    # Returns the databases from the yml file.
+    def self.databases
+      @databases
+    end
+    
+    # Returns the +Users+ loaded from the replication.yml file
+    def self.users
+      @users
+    end
+  
+    def self.diff_tables
+      unsynced_dbs = 0
+    
+      databases.each_pair do |name, roles|
+        master, slave = roles['master'], roles['slave']
+        deltas = DeltaMonitor.diff(name, master, slave)
+                                  
+        egregious_deltas = deltas.select{|table, delta| delta > configs['row_difference_threshold'] }                           
+        if egregious_deltas.size > 0
+          queue_replication_warning :host => master[:host], :database => master[:database], :deltas => egregious_deltas, :noticed_at => Time.now
+          unsynced_dbs += 1
+        end
+      end
+    
+      unsynced_dbs.zero?
+    end
+  
+    def self.heartbeat
+      databases.each_key do |name|
+        Heartbeat.write(name, databases[name]['master'])
+      end
+    
+      overdue_slaves = 0
+    
+      databases.each_key do |name|
+        db_configs = databases[name]['slave']
+        delay = Heartbeat.read(name, db_configs)
+        if delay.nil?
+          queue_replication_warning :host => name, 
+                                    :database => configs[:database], 
+                                    :general_error => "Error: No Heartbeats found.", 
+                                    :noticed_at => Time.now
+          overdue_slaves += 1
+        elsif delay > configs['delay_threshold_secs']
+          queue_replication_warning :host => name, 
+                                    :database => configs[:database], 
+                                    :delay => Heartbeat.strfdelay(delay), 
+                                    :noticed_at => Time.now
+          overdue_slaves += 1
+        end
+      end
+    
+      overdue_slaves.zero?
+    end
+  
+    # Checks the status of each slave.
+    def self.check_slaves
+      databases.slaves.each do |slave_name, slave_configs|
+        status = Status.check_slave_status(slave_name, slave_configs)
+        if status != Status.const_get(:RUNNING)
+          queue_replication_warning :host => name, 
+                                    :database => configs[:database], 
+                                    :status_error => Status.get_error_message(status), 
+                                    :noticed_at => Time.now
+        end
+      end
+    end
+  
+    def self.queue_replication_warning(options)
+      email = OpenStruct.new
+      email.recipients = get_recipients
+      email.subject = "A replication error occured on #{options[:host]} at #{Time.now}"
+      email.body = ''
+    
+      if options[:delay]
+        email.body +=  "There was a #{delay} second replication latency, which is greater than the allowed latency of #{configs['delay_threshold_secs']} seconds"
+      elsif options[:deltas]
+        email.body += "The following tables have master/slave row count difference greater than the allowed #{configs['row_difference_threshold']}\n\n"
+        options[:deltas].each do |table, delta|      
+          email.body += "   table '#{table}' was off by #{delta} rows\n"
+        end
+      elsif options[:status_error]
+          email.body += "   MySQL Status message: #{options[:status_error]}"
+      elsif options[:general_error]
+          email.body += "   Error: #{options[:general_error]}"
+      end
+    
+      email.body += "\n"
+      email.body += "  Server: #{options[:host]}\n"
+      email.body += "  Databse: #{options[:database]}\n"
+    
+      send_email(email)
+    end
+  
+    # Gets the 'email_to' value from the 'configs' section of the replication.yml file
+    def self.get_recipients
+      configs['email_to']
+    end
+  
+    # Gets the 'email_from' value from the 'configs' section of the replication.yml file
+    def self.get_sender
+      configs['email_from']
+    end
+  
+    def self.report
+      email = OpenStruct.new
+      email.recipients = get_recipients
+      email.sender = get_sender
+      raise "Please specify report recipients 'email_to: user@address.com'" if email.recipients.nil?
+      raise "Please specify report recipients 'email_from: user@address.com'" if email.sender.nil?
+    
+      email.subject = "Daily Replication Report for #{Time.now.strftime('%D')}"
+    
+      puts "Generating report email"
+    
+      old_stdout = $stdout
+      out = StringIO.new
+      $stdout = out
+      begin
+        puts "                       Checking slave status"
+        puts
+        self.check_slaves
+        puts
+        puts
+        puts "                       Checking table row counts"
+        puts
+        puts "The row count difference threshold is #{configs['row_difference_threshold']} rows"
+        puts
+        self.diff_tables
+        puts
+        puts
+        puts "                       Checking replication heartbeat"
+        puts
+        puts "The heartbeat latency threshold is #{configs['delay_threshold_secs']} seconds"
+        puts
+        self.heartbeat
+      ensure
+         $stdout = old_stdout
+      end
+      email.body = out.string
+    
+      puts "Sending report email"
+    
+      send_email(email)
+    
+      puts "Report sent to #{get_recipients}"
+    end
+  
+    def self.send_exception_email(ex)
+      email = OpenStruct.new
+      email.recipients = get_recipients
+      email.sender = get_sender
+      email.subject = "An exception occured while checking replication at #{Time.now}"
+      email.body = 'Expception\n\n'
+      email.body += "#{ex.message}\n"
+      ex.backtrace.each do |line| 
+         email.body += "#{line}\n"
+      end
+    
+      send_email(email)
+    end
+  
+    def self.send_email(email)
+      # TODO: could do Net::SMTP.respond_to?(enable_tls) ? enable_TLS : puts "Install TLS gem to use SSL/TLS"
+      Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
+      Net::SMTP.start(configs['email_server'], 
+                        configs['email_port'], 
+                        configs['email_domain'], 
+                        get_sender,
+                        configs['email_password'], 
+                        configs['email_auth_type'].to_sym) do |smtp|
+          email.recipients.each do |email_addy|
+            hdr = "From: #{email.sender}\n"
+            hdr += "To: #{email_addy} <#{email_addy}>\n" 
+            hdr += "Subject: #{email.subject}\n\n"
+            msg = hdr + email.body
+            puts "Sending to #{email_addy}"
+            smtp.send_message msg, email.sender,  email_addy
+        end
+      end
+    # TODO: could try and recover
+    # rescue Net::SMTPAuthenticationError => e
+    #     if e.message =~ /504 5.7.4 Unrecognized authentication type/
+    #       puts "Attempting to load necesary files for TLS/SSL authentication"
+    #       puts "Make sure openssl and the tlsmail gem are installed"
+    #       require 'openssl'
+    #       require 'rubygems'
+    #       has_tlsmail_gem = require 'tlsmail'
+    #       raise "Please install the 'tlsmail' gem" unless has_tlsmail_gem
+    #       Net::SMTP.enable_tls(OpenSSL::SSL::VERIFY_NONE)
+    #       send_email(email)
+    #     end
+    end
+
+  end
+end

data/lib/reptile/runner.rb

@@ -0,0 +1,116 @@
+module Reptile
+  # The runner class is responsible for running command on each slave.  
+  # The commands are run sequentially, no guaranteed order (though probably from yml file).
+  class Runner
+    # Set the user settings for a user that has REPLICATION SLAVE privilidgess
+    def self.user=(replication_user_settings)
+      @repl_user = replication_user_settings
+    end
+
+    # The user settings for a user that has REPLICATION SLAVE privilidgess
+    def self.user
+      raise "You need to specify a replication user!" if @repl_user.nil?
+      @repl_user
+    end
+
+    # Set the databases to run command upon.
+    def self.databases=(databases)
+      @databases = databases
+    end
+
+    # The databases to run commands upon.
+    def self.databases
+      @databases
+    end    
+
+    # Set the slaves to run command upon.
+    def self.slaves=(slaves)
+      slaves.each do |name, configs|
+        configs.delete('port')
+        configs.delete('host')
+        # With activeRecord, you have to connect to some DB, even if you are acting on the server...
+        configs['database'] = 'information_schema'
+        # TODO: Delete these somewhere else
+        configs.delete('heartbeat')
+        configs.delete('replication_user')
+      end
+      @slaves = slaves
+    end
+
+    # The slaves to run commands upon.
+    def self.slaves
+      raise "You need to specify the slaves to run against!" if @slaves.nil?
+      @slaves
+    end
+    
+    
+    # Tries to establish a database connection, and returns that connection.  
+    # Dumps configs on error.
+    def self.connect(configs)
+      ActiveRecord::Base.establish_connection(configs)
+      ActiveRecord::Base.connection
+    rescue Exception => e
+      puts "****"
+      puts "Error connecting to database: #{e}"
+      puts "****"
+      puts YAML::dump(configs)
+      exit 1
+    end
+
+    # Executes a command on all the slaves, sequentially.
+    # Takes an optional set of connection paramters to override defaults.
+    def self.execute_on_slaves(cmd, configs={})
+      slaves.each do |name, slave_configs|
+        puts "Executing #{cmd} on #{name}"
+        puts slave_configs.inspect
+        connection = connect(slave_configs.merge(user).merge(configs))
+        connection.execute(cmd)
+      end      
+    end
+
+    # Execute STOP SLAVE on all slaves;
+    def self.stop_slaves
+      execute_on_slaves("STOP SLAVE;")
+    end
+    
+    # Execute START SLAVE on all slaves.
+    def self.start_slaves
+      execute_on_slaves("START SLAVE;")
+    end 
+    
+    # Creates users with specific permissions on the different mysql servers, both masters and slaves.
+    # Prompts for username and password of an account that has GRANT priviledges.
+    def self.setup
+      raise "GET CONFIGS"
+      grant_user_configs = User.prompt_for_grant_user
+      # TODO: use specific tables, not *.*
+      # TODO: are these on localhost? or where?
+      # TODO: We need all databases in order to grant permissions there.
+      # TODO: There could be a different GRANT password for each mysql server, so identify which before asking for permissions.
+      execute_on_slaves("GRANT select ON *.* TO #{ro_user}@???? INDENTIFIED BY #{ro_password}", grant_user_configs)
+      execute_on_slaves("GRANT select ON *.* TO #{repl_user}@???? INDENTIFIED BY #{repl_password}", grant_user_configs)
+    end
+    
+    def self.setup_heartbeat
+      # MySQL DTD for setting up Heartbeats.  Change HEARTBEAT_USER, HEARTBEAT_PASS, and MONITORING_BOX to ip of the monitoring server.
+      # GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'HEARTBEAT_USER'@"localhost" IDENTIFIED BY 'HEARTBEAT_PASS';
+      # GRANT SELECT, INSERT, UPDATE, ALTER ON replication_monitor.* TO 'HEARTBEAT_USER'@"MONITORING_BOX" IDENTIFIED BY 'HEARTBEAT_PASS';
+      # 
+      # CREATE DATABASE replication_monitor;
+      # 
+      # CREATE TABLE replication_monitor.heartbeats (
+      #   unix_time INTEGER NOT NULL, 
+      #   db_time TIMESTAMP NOT NULL, 
+      #   INDEX time_idx(unix_time)
+      # )
+    end
+    
+    def self.test_connections
+      databases.each do |db|
+        databases.roles.each do |role|
+          db[role]
+        end
+      end
+    end
+  end
+end

data/lib/reptile/status.rb

@@ -0,0 +1,79 @@
+require 'tlsmail'
+
+module Reptile
+  # The Status class is responsible for asking a slave database for its status is, 
+  # parsing the result, and returning the appropiate status code.
+  #
+  # This class also allows you to convert a status code to a friendly message the corresponds to that status.
+  
+  class Status
+
+    @@errors = []
+    
+    # Status code indicating the SQL thread has stopped running.
+    SQL_THREAD_DOWN = 'sql_thread_down'
+    
+    # Status code indicating the IO thread has stopped running.
+    IO_THREAD_DOWN = 'io_thread_down'
+    
+    # Status code indicating that the slave has stopped replicating.
+    SLAVE_DOWN = 'slave_down'
+    
+    # Status code indicating that the slave is up and running.
+    RUNNING = 'running'
+    
+    # Set the user settings for a user that has global SELECT privilidgess
+    def self.user=(user_settings)
+      @user = user_settings
+    end
+
+    # The user settings for a user that has global select privilidgess
+    def self.user
+      raise "You need to specify a user!" if @user.nil?
+      @user
+    end
+    
+    # Checks the value of the MySQL command "SHOW SLAVE STATUS".
+    # Returns a status code.
+    def self.check_slave_status(name, configs)
+      # TODO: Do this in Databases
+      configs.delete("port")
+      configs['database'] = "information_schema"
+      Databases.connect(configs.merge(user)).execute('SHOW SLAVE STATUS').each do |row|
+        if row =~ /Slave_SQL_Running/ && row =~ /No/
+          return SQL_THREAD_DOWN
+        elsif row =~ /Slave_IO_Running/ && row =~ /No/
+          return IO_THREAD_DOWN
+        elsif row =~ /Slave_Running/ && row =~ /No/
+          return SLAVE_DOWN
+        else
+          return RUNNING
+        end
+      end
+    end 
+    
+    # Returns a nice error message for the given status code
+    def self.get_error_message(status)
+      case status
+      when SQL_THREAD_DOWN
+        "The SQL thread has stopped"
+      when IO_THREAD_DOWN
+        "The IO thread has stopped"
+      when SLAVE_DOWN
+        "The slave has stoppped"
+      else
+        raise "Invalid status code.  Must be one of #{status_codes.keys.inspect}"
+      end
+    end
+    
+    # A hash containing the names of the constants that represent status codes,
+    # and the strings they represent
+    def self.status_codes
+      status_codes = {}
+      self.constants.each do |const|
+        status_codes[const] = const_get(const)
+      end
+      status_codes
+    end
+  end
+end

data/lib/reptile/users.rb

@@ -0,0 +1,64 @@
+module Reptile
+  # The Users class is holds the different sets of parameters for logging into a database, 
+  # including username, password, etc. There are read_only configs, replication user configs, 
+  # heartbeat configs, etc, for correctly and safely allowing access to different databases for
+  # different reasons.  
+  #
+  # This also data also is used to create the permissions, allowing the setup of replication 
+  # to be even easier.
+  class Users
+    def initialize(options)
+      @repl_user = options["replication_user"]
+      @ro_user = options["ro_user"]
+      @heartbeat_user = options["heartbeat_user"]
+    end
+    
+    
+    def self.prompt_for_grant_user
+      require 'rubygems'
+      require 'highline'
+      
+      asker = HighLine.new
+      asker.say("Please enter credentials for a user that has GRANT priviledges.")
+      {:username => asker.ask("Enter your username:"), 
+       :password => asker.ask("Enter your password:  ") { |q| q.echo = "x" }}
+    end
+    
+    # # Set the user settings for a user that has REPLICATION SLAVE privilidgess
+    # def replication_user=(replication_user_settings)
+    #   @repl_user = replication_user_settings
+    # end
+
+    # The user settings for a user that has REPLICATION SLAVE privilidgess
+    def replication_user
+      # TODO: only bail on getting a user if it is acutally used
+      #raise "You need to specify a replication user!" if @repl_user.nil?
+      @repl_user
+    end
+        
+    
+    # # Set the user settings for a user that has SELECT privilidgess
+    # def ro_user=(ro_user_settings)
+    #   @ro_user = ro_user_settings
+    # end
+
+    # The user settings for a user that has SELECT privilidgess
+    def ro_user
+      #raise "You need to specify a SELECT user!" if @ro_user.nil?
+      @ro_user || {}
+    end
+    
+
+    # # Set the user settings for a user that has reads/writes heartbeats
+    # def heartbeat_user=(heartbeat_user_settings)
+    #   @heartbeat_user = heartbeat_user_settings
+    # end
+
+    # The user settings for a user that reads/writes heartbeats
+    def heartbeat_user
+      #raise "You need to specify a heartbeat user!" if @heartbeat_user.nil?
+      @heartbeat_user || {}
+    end
+
+  end
+end

data/lib/reptile.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'ostruct'
+require 'openssl'
+require 'rubygems'
+require 'tlsmail'
+require 'net/smtp'
+
+
+require 'reptile/heartbeat'
+require 'reptile/delta_monitor'
+require 'reptile/replication_monitor'
+require 'reptile/status'
+require 'reptile/runner'
+require 'reptile/users'
+require 'reptile/databases'
+
+require 'active_record'
+
+module Reptile
+  VERSION = '0.0.1'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/reptile.rb'}"
+puts "Loading reptile gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/reptile'

data/test/test_reptile.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestReptile < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: reptile
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- FIXME full name
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-26 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: ""
+email: 
+- FIXME email
+executables: 
+- replication_status
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- bin/replication_status
+- lib/reptile.rb
+- lib/reptile/databases.rb
+- lib/reptile/delta_monitor.rb
+- lib/reptile/dtd.sql
+- lib/reptile/heartbeat.rb
+- lib/reptile/replication_monitor.rb
+- lib/reptile/runner.rb
+- lib/reptile/status.rb
+- lib/reptile/users.rb
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_reptile.rb
+has_rdoc: true
+homepage: Reptile is an easy to use utility that will monitor your MySQL replication, so you can forget about it and focus on the good stuff.  It provides a utility for generate replication reports, and can email if replication appears to be failing.
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: reptile
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: ""
+test_files: 
+- test/test_helper.rb
+- test/test_reptile.rb