mysql_warmer 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Rohith Ravi
+
+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/README.rdoc

@@ -0,0 +1,37 @@
+= mysql_warmer
+
+The need for mysql_warmer arose out of having to add a newly seeded MySQL slave in to production rotation. Since the internal buffer pool is empty / not tuned for the queries that will be run on it, queries that would run in less than 1s often took > 1much higher with a cold MySQL cache.
+
+To alleviate the pain of addding a cold / untuned MySQL machine to the cluster, mysql_warmer simply executes the same queries that are being run on a warm slave, on a cold slave. You're expected to run a query reaper on the slave with some reasonable timeout so that the initial flood of slow queries will not kill the machine. And once enough time has gone by, both the warm slave and the cold slave will start exhibiting identical performance characteristics and then we can give production traffic to the new slave.
+
+== Install
+
+mysql_warmer has many dependencies. Make sure your system has libpcap installed with the dev headers.
+
+    $ sudo yum install libpcap libpcap-devel
+    $ gem install mysql_warmer
+
+== Usage
+
+On the cold slave:
+
+    $ mysql_warmer -u root -p sekret production_db &
+    $ <start a query reaper with a timeout of 10s or similar>
+
+On the warm slave:
+
+    $ sudo mysql_sniff <cold_slave_ip>
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Rohith Ravi. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mysql_warmer"
+    gem.summary = %Q{Couple command line utilities to warm a cold MySQL database}
+    gem.description = %Q{mysql_warmer warms up a cold database by sniffing SQL queries from a hot machine and then repeating those queries on a cold machine}
+    gem.email = "entombedvirus@gmail.com"
+    gem.homepage = "http://github.com/entombedvirus/mysql_warmer"
+    gem.authors = ["Rohith Ravi", "Steven Lumos"]
+    gem.add_dependency "eventmachine", ">= 0.12.9"
+    gem.add_dependency "mysqlplus", ">= 0.1.0"
+    gem.add_dependency "pcap"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mysql_warmer #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/mysql_sniff

@@ -0,0 +1,61 @@
+#! /usr/bin/env ruby
+
+require 'pcaplet'
+require 'socket'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: sudo mysql_sniff [OPTIONS] <mysql_warmer_host> [mysql_warmer_port]'
+
+  options[:verbose] = false
+  opts.on('-v', '--verbose', 'Outputs the SQL queries sniffed off the wire') do |verbose|
+    options[:verbose] = true
+  end
+end.parse!
+
+
+warmer_host = ARGV.shift
+warmer_port = (ARGV.shift || 10169).to_i
+
+if warmer_host.nil?
+  puts "Please specify where the mysql_warmer script is running"
+  return
+end
+
+MYSQL_COM_QUERY = 0x03
+
+mysqlsniff = Pcaplet.new('-s 65535 -i eth0')
+mysqlsniff.add_filter Pcap::Filter.new('tcp port 3306', mysqlsniff.capture)
+
+query = ''
+query_length = 0
+
+mysqlsniff.each_packet do |pkt|
+  next unless pkt.tcp_data
+  if query then
+    if query.length == query_length then
+      if options[:verbose]
+        puts query
+        puts '-' * 80
+      end
+
+      s = TCPSocket.open(warmer_host, warmer_port)
+      s.write(query)
+      s.close
+
+      query = nil
+      query_length = 0
+    else
+      query << pkt.tcp_data
+    end
+  end
+
+  if pkt.tcp_data[3] == 0 and pkt.tcp_data[4] == MYSQL_COM_QUERY then
+    query_length = (pkt.tcp_data[0,3] + "\0").unpack('V')[0] - 1
+    next if query_length < 1
+    query = pkt.tcp_data[5..-1]
+  end
+end
+

data/bin/mysql_warmer

@@ -0,0 +1,72 @@
+#! /usr/bin/env ruby
+#
+
+require 'rubygems'
+require 'mysql_warmer'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: mysql_warmer [options] <db_name>"
+
+  options[:verbose] = false
+  opts.on('-v', '--verbose', 'Prints queries that are being run to warm up the db') do
+    options[:verbose] = true
+  end
+
+  options[:db_opts] = {}
+  opts.on('-u USER', 'Username to use when connecting to the cold database') do |username|
+    options[:db_opts][:username] = username
+  end
+  opts.on('-p PASSWORD', 'Password to use when connecting to the cold database') do |password|
+    options[:db_opts][:password] = password
+  end
+  opts.on('-h HOST', 'Hostname to use when connecting to the cold database') do |hostname|
+    options[:db_opts][:host] = hostname
+  end
+
+
+  options[:listen_port] = 10169
+  opts.on('-l PORT', "Port to listen on for queries. Default is #{options[:listen_port]}") do |port|
+    options[:listen_port] = port.to_i
+  end
+end.parse!
+
+options[:db_opts][:database] = ARGV.shift
+options[:db_opts].update(:on_error => proc {|e| STDERR.puts "%s - %s" % [e.class.name, e.message]}, :connections => 100)
+
+if options[:db_opts][:database].nil?
+  puts "Please specify a database to run the queries aganist."
+  return
+end
+
+SQL = MysqlWarmer::EventedMysql
+SQL.settings.update options[:db_opts]
+
+module MysqlSpammer
+  def initialize(options)
+    @options = options
+    @query = ""
+  end
+
+  def receive_data(data)
+    @query << data
+  end
+  
+  def unbind
+    return if @query.empty?
+  
+    puts @query.inspect if @options[:verbose]
+    SQL.raw(@query) {}
+  end
+end
+
+trap("INT") { EM.stop_event_loop; puts "Exiting..." }
+
+EM.run do
+  EM.start_server '0.0.0.0', options[:listen_port], MysqlSpammer, options
+  puts "Waiting for queries on port %d..." % options[:listen_port]
+end
+
+

data/lib/mysql_warmer.rb

@@ -0,0 +1,6 @@
+DIR = File.expand_path(File.dirname(File.expand_path(__FILE__)))
+$:.unshift DIR
+
+
+require 'eventmachine'
+require 'mysql_warmer/em/mysql'

data/lib/mysql_warmer/em/mysql.rb

@@ -0,0 +1,476 @@
+require 'rubygems'
+require 'eventmachine'
+require 'mysqlplus'
+require 'fcntl'
+
+class Mysql
+  def result
+    @cur_result
+  end
+end
+
+module MysqlWarmer
+  class EventedMysql < EM::Connection
+    def initialize mysql, opts
+      @mysql = mysql
+      @fd = mysql.socket
+      @opts = opts
+      @current = nil
+      @@queue ||= []
+      @processing = false
+      @connected = true
+
+      log 'mysql connected'
+
+      self.notify_readable = true
+      EM.add_timer(0){ next_query }
+    end
+    attr_reader :processing, :connected, :opts
+    alias :settings :opts
+
+    DisconnectErrors = [
+    'query: not connected',
+    'MySQL server has gone away',
+    'Lost connection to MySQL server during query'
+    ] unless defined? DisconnectErrors
+
+    def notify_readable
+      log 'readable'
+      if item = @current
+        @current = nil
+        start, response, sql, cblk, eblk = item
+        log 'mysql response', Time.now-start, sql
+        arg = case response
+              when :raw
+                result = @mysql.get_result
+                @mysql.instance_variable_set('@cur_result', result)
+                @mysql
+              when :select
+                ret = []
+                result = @mysql.get_result
+                result.each_hash{|h| ret << h }
+                log 'mysql result', ret
+                ret
+              when :update
+                result = @mysql.get_result
+                @mysql.affected_rows
+              when :insert
+                result = @mysql.get_result
+                @mysql.insert_id
+              else
+                result = @mysql.get_result
+                log 'got a result??', result if result
+                nil
+              end
+
+        @processing = false
+        # result.free if result.is_a? Mysql::Result
+        next_query
+        cblk.call(arg) if cblk
+      else
+        log 'readable, but nothing queued?! probably an ERROR state'
+        return close
+      end
+    rescue Mysql::Error => e
+      log 'mysql error', e.message
+      if e.message =~ /Deadlock/
+        @@queue << [response, sql, cblk, eblk]
+        @processing = false
+        next_query
+      elsif DisconnectErrors.include? e.message
+        @@queue << [response, sql, cblk, eblk]
+        return close
+      elsif cb = (eblk || @opts[:on_error])
+        cb.call(e)
+        @processing = false
+        next_query
+      else
+        raise e
+      end
+      # ensure
+      #   res.free if res.is_a? Mysql::Result
+      #   @processing = false
+      #   next_query
+    end
+
+    def unbind
+      log 'mysql disconnect', $!
+      # cp = EventedMysql.instance_variable_get('@connection_pool') and cp.delete(self)
+      @connected = false
+
+      # XXX wait for the next tick until the current fd is removed completely from the reactor
+      #
+      # XXX in certain cases the new FD# (@mysql.socket) is the same as the old, since FDs are re-used
+      # XXX without next_tick in these cases, unbind will get fired on the newly attached signature as well
+      #
+      # XXX do _NOT_ use EM.next_tick here. if a bunch of sockets disconnect at the same time, we want
+      # XXX reconnects to happen after all the unbinds have been processed
+      EM.add_timer(0) do
+        log 'mysql reconnecting'
+        @processing = false
+        @mysql = EventedMysql._connect @opts
+        @fd = @mysql.socket
+
+        @signature = EM.attach_fd @mysql.socket, true
+        EM.set_notify_readable @signature, true
+        log 'mysql connected'
+        EM.instance_variable_get('@conns')[@signature] = self
+        @connected = true
+        # make_socket_blocking
+        next_query
+      end
+    end
+
+    def execute sql, response = nil, cblk = nil, eblk = nil, &blk
+      cblk ||= blk
+
+      begin
+        unless @processing or !@connected
+          # begin
+          #   log 'mysql ping', @mysql.ping
+          #   # log 'mysql stat', @mysql.stat
+          #   # log 'mysql errno', @mysql.errno
+          # rescue
+          #   log 'mysql ping failed'
+          #   @@queue << [response, sql, blk]
+          #   return close
+          # end
+
+          @processing = true
+
+          log 'mysql sending', sql
+          @mysql.send_query(sql)
+        else
+          @@queue << [response, sql, cblk, eblk]
+          return
+        end
+      rescue Mysql::Error => e
+        log 'mysql error', e.message
+        if DisconnectErrors.include? e.message
+          @@queue << [response, sql, cblk, eblk]
+          return close
+        else
+          raise e
+        end
+      end
+
+      log 'queuing', response, sql
+      @current = [Time.now, response, sql, cblk, eblk]
+    end
+
+    def close
+      @connected = false
+      fd = detach
+      log 'detached fd', fd
+    end
+
+    private
+
+    def next_query
+      if @connected and !@processing and pending = @@queue.shift
+        response, sql, cblk, eblk = pending
+        execute(sql, response, cblk, eblk)
+      end
+    end
+
+    def log *args
+      return unless @opts[:logging]
+      p [Time.now, @fd, (@signature[-4..-1] if @signature), *args]
+    end
+
+    public
+
+    def self.connect opts
+      puts EM.respond_to?(:watch)
+      unless EM.respond_to?(:watch) and Mysql.method_defined?(:socket)
+        raise RuntimeError, 'mysqlplus and EM.watch are required for EventedMysql'
+      end
+
+      if conn = _connect(opts)
+        EM.watch conn.socket, self, conn, opts
+      else
+        EM.add_timer(5){ connect opts }
+      end
+    end
+
+    self::Mysql = ::Mysql unless defined? self::Mysql
+
+    # stolen from sequel
+    def self._connect opts
+      opts = settings.merge(opts)
+
+      conn = Mysql.init
+
+      # set encoding _before_ connecting
+      if charset = opts[:charset] || opts[:encoding]
+        conn.options(Mysql::SET_CHARSET_NAME, charset)
+      end
+
+      conn.options(Mysql::OPT_LOCAL_INFILE, 'client')
+
+      conn.real_connect(
+        opts[:host] || 'localhost',
+        opts[:user] || 'root',
+        opts[:password],
+        opts[:database],
+        opts[:port],
+        opts[:socket],
+        0 +
+        # XXX multi results require multiple callbacks to parse
+        # Mysql::CLIENT_MULTI_RESULTS +
+        # Mysql::CLIENT_MULTI_STATEMENTS +
+        (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
+      )
+
+      # increase timeout so mysql server doesn't disconnect us
+      # this is especially bad if we're disconnected while EM.attach is
+      # still in progress, because by the time it gets to EM, the FD is
+      # no longer valid, and it throws a c++ 'bad file descriptor' error
+      # (do not use a timeout of -1 for unlimited, it does not work on mysqld > 5.0.60)
+      conn.query("set @@wait_timeout = #{opts[:timeout] || 2592000}")
+
+      # we handle reconnecting (and reattaching the new fd to EM)
+      conn.reconnect = false
+
+      # By default, MySQL 'where id is null' selects the last inserted id
+      # Turn this off. http://dev.rubyonrails.org/ticket/6778
+      conn.query("set SQL_AUTO_IS_NULL=0")
+
+      # get results for queries
+      conn.query_with_result = true
+
+      conn
+    rescue Mysql::Error => e
+      if cb = opts[:on_error]
+        cb.call(e)
+        nil
+      else
+        raise e
+      end
+    end
+  end
+
+  class EventedMysql
+    def self.settings
+      @settings ||= { :connections => 4, :logging => false }
+    end
+
+    def self.execute query, type = nil, cblk = nil, eblk = nil, &blk
+      unless nil#connection = connection_pool.find{|c| not c.processing and c.connected }
+        @n ||= 0
+        connection = connection_pool[@n]
+        @n = 0 if (@n+=1) >= connection_pool.size
+      end
+
+      connection.execute(query, type, cblk, eblk, &blk)
+    end
+
+  %w[ select insert update raw ].each do |type| class_eval %[
+
+    def self.#{type} query, cblk = nil, eblk = nil, &blk
+      execute query, :#{type}, cblk, eblk, &blk
+    end
+
+  ] end
+
+  def self.all query, type = nil, &blk
+    responses = 0
+    connection_pool.each do |c|
+      c.execute(query, type) do
+        responses += 1
+        blk.call if blk and responses == @connection_pool.size
+      end
+    end
+  end
+
+  def self.connection_pool
+    @connection_pool ||= (1..settings[:connections]).map{ EventedMysql.connect(settings) }
+    # p ['connpool', settings[:connections], @connection_pool.size]
+    # (1..(settings[:connections]-@connection_pool.size)).each do
+    #   @connection_pool << EventedMysql.connect(settings)
+    # end unless settings[:connections] == @connection_pool.size
+    # @connection_pool
+  end
+  end
+
+  if __FILE__ == $0 and require 'em/spec'
+
+    EM.describe EventedMysql, 'individual connections' do
+
+    should 'create a new connection' do
+      @mysql = EventedMysql.connect :host => '127.0.0.1',
+        :port => 3306,
+        :database => 'test',
+        :logging => false
+
+      @mysql.class.should == EventedMysql
+      done
+    end
+
+    should 'execute sql' do
+      start = Time.now
+
+      @mysql.execute('select sleep(0.2)'){
+        (Time.now-start).should.be.close 0.2, 0.1
+        done
+      }
+    end
+
+    should 'reconnect when disconnected' do
+      @mysql.close
+      @mysql.execute('select 1+2'){
+        :connected.should == :connected
+        done
+      }
+    end
+
+    # to test, run:
+    #   mysqladmin5 -u root kill `mysqladmin5 -u root processlist | grep "select sleep(5)+1" | cut -d'|' -f2`
+    #
+    # should 're-run query if disconnected during query' do
+    #   @mysql.execute('select sleep(5)+1', :select){ |res|
+    #     res.first['sleep(5)+1'].should == '1'
+    #     done
+    #   }
+    # end
+
+    should 'run select queries and return results' do
+      @mysql.execute('select 1+2', :select){ |res|
+        res.size.should == 1
+        res.first['1+2'].should == '3'
+        done
+      }
+    end
+
+    should 'queue up queries and execute them in order' do
+      @mysql.execute('select 1+2', :select)
+      @mysql.execute('select 2+3', :select)
+      @mysql.execute('select 3+4', :select){ |res|
+        res.first['3+4'].should == '7'
+        done
+      }
+    end
+
+    should 'continue processing queries after hitting an error' do
+      @mysql.settings.update :on_error => proc{|e|}
+
+      @mysql.execute('select 1+ from table'){}
+      @mysql.execute('select 1+1 as num', :select){ |res|
+        res[0]['num'].should == '2'
+        done
+      }
+    end
+
+    should 'have raw mode which yields the mysql object' do
+      @mysql.execute('select 1+2 as num', :raw){ |mysql|
+        mysql.should.is_a? Mysql
+        mysql.result.all_hashes.should == [{'num' => '3'}]
+        done
+      }
+    end
+
+    should 'allow custom error callbacks for each query' do
+      @mysql.settings.update :on_error => proc{ should.flunk('default errback invoked') }
+
+      @mysql.execute('select 1+ from table', :select, proc{
+        should.flunk('callback invoked')
+      }, proc{ |e|
+        done
+      })
+    end
+
+  end
+
+  EM.describe EventedMysql, 'connection pools' do
+
+    EventedMysql.settings.update :connections => 3
+
+    should 'run queries in parallel' do
+      n = 0
+      EventedMysql.select('select sleep(0.25)'){ n+=1 }
+      EventedMysql.select('select sleep(0.25)'){ n+=1 }
+      EventedMysql.select('select sleep(0.25)'){ n+=1 }
+
+      EM.add_timer(0.30){
+        n.should == 3
+        done
+      }
+    end
+
+  end
+
+  SQL = EventedMysql
+  def SQL(query, &blk) SQL.select(query, &blk) end
+
+  # XXX this should get cleaned up automatically after reactor stops
+  SQL.instance_variable_set('@connection_pool', nil)
+
+
+  EM.describe SQL, 'sql api' do
+
+    should 'run a query on all connections' do
+      SQL.all('use test'){
+        :done.should == :done
+        done
+      }
+    end
+
+    should 'execute queries with no results' do
+      SQL.execute('drop table if exists evented_mysql_test'){
+        :table_dropped.should == :table_dropped
+        SQL.execute('create table evented_mysql_test (id int primary key auto_increment, num int not null)'){
+          :table_created.should == :table_created
+          done
+        }
+      }
+    end
+
+    should 'insert rows and return inserted id' do
+      SQL.insert('insert into evented_mysql_test (num) values (10),(11),(12)'){ |id|
+        id.should == 1
+        done
+      }
+    end
+
+    should 'select rows from the database' do
+      SQL.select('select * from evented_mysql_test'){ |res|
+        res.size.should == 3
+        res.first.should == { 'id' => '1', 'num' => '10' }
+        res.last.should  == { 'id' => '3', 'num' => '12' }
+        done
+      }
+    end
+
+    should 'update rows and return affected rows' do
+      SQL.update('update evented_mysql_test set num = num + 10'){ |changed|
+        changed.should == 3
+        done
+      }
+    end
+
+    should 'allow access to insert_id in raw mode' do
+      SQL.raw('insert into evented_mysql_test (num) values (20), (21), (22)'){ |mysql|
+        mysql.insert_id.should == 4
+        done
+      }
+    end
+
+    should 'allow access to affected_rows in raw mode' do
+      SQL.raw('update evented_mysql_test set num = num + 10'){ |mysql|
+        mysql.affected_rows.should == 6
+        done
+      }
+    end
+
+    should 'fire error callback with exceptions' do
+      SQL.settings.update :on_error => proc{ |e|
+        e.class.should == Mysql::Error
+        done
+      }
+      SQL.select('select 1+ from table'){}
+    end
+
+  end
+
+end
+end

data/mysql_warmer.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mysql_warmer}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rohith Ravi", "Steven Lumos"]
+  s.date = %q{2010-01-21}
+  s.description = %q{mysql_warmer warms up a cold database by sniffing SQL queries from a hot machine and then repeating those queries on a cold machine}
+  s.email = %q{entombedvirus@gmail.com}
+  s.executables = ["mysql_sniff", "mysql_warmer"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/mysql_sniff",
+     "bin/mysql_warmer",
+     "lib/mysql_warmer.rb",
+     "lib/mysql_warmer/em/mysql.rb",
+     "mysql_warmer.gemspec",
+     "test/helper.rb",
+     "test/test_mysql_warmer.rb"
+  ]
+  s.homepage = %q{http://github.com/entombedvirus/mysql_warmer}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Couple command line utilities to warm a cold MySQL database}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_mysql_warmer.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.9"])
+      s.add_runtime_dependency(%q<mysqlplus>, [">= 0.1.0"])
+      s.add_runtime_dependency(%q<pcap>, [">= 0"])
+    else
+      s.add_dependency(%q<eventmachine>, [">= 0.12.9"])
+      s.add_dependency(%q<mysqlplus>, [">= 0.1.0"])
+      s.add_dependency(%q<pcap>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<eventmachine>, [">= 0.12.9"])
+    s.add_dependency(%q<mysqlplus>, [">= 0.1.0"])
+    s.add_dependency(%q<pcap>, [">= 0"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'mysql_warmer'
+
+class Test::Unit::TestCase
+end

data/test/test_mysql_warmer.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestMysqlWarmer < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: mysql_warmer
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rohith Ravi
+- Steven Lumos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-21 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.12.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mysqlplus
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: pcap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: mysql_warmer warms up a cold database by sniffing SQL queries from a hot machine and then repeating those queries on a cold machine
+email: entombedvirus@gmail.com
+executables: 
+- mysql_sniff
+- mysql_warmer
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/mysql_sniff
+- bin/mysql_warmer
+- lib/mysql_warmer.rb
+- lib/mysql_warmer/em/mysql.rb
+- mysql_warmer.gemspec
+- test/helper.rb
+- test/test_mysql_warmer.rb
+has_rdoc: true
+homepage: http://github.com/entombedvirus/mysql_warmer
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Couple command line utilities to warm a cold MySQL database
+test_files: 
+- test/helper.rb
+- test/test_mysql_warmer.rb