jetpants 0.7.10 → 0.8.0

data/README.rdoc

@@ -76,12 +76,16 @@ If you have a question that isn't covered here, please feel free to email the au
 
 == CREDITS:
 
-* <b>Evan Elias</b>: Lead developer. Core class implementations, shard split logic, plugin system
-* <b>Dallas Marlow</b>: Master promotion logic, command suite and console structure, MySQL internals expertise
+* <b>Evan Elias</b>: Lead developer
+* <b>Dallas Marlow</b>: Developer
+* <b>Bob Patterson Jr</b>: Developer
+* <b>Tom Christ</b>: Developer
+
+Special thanks to <b>Tim Ellis</b> for testing and bug reports.
 
 == LICENSE:
 
-Copyright 2012 Tumblr, Inc.
+Copyright 2013 Tumblr, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/bin/jetpants

@@ -4,8 +4,6 @@
 # module in a Thor command processor, providing a command-line interface to
 # common Jetpants functionality.
 
-jetpants_base_dir = File.expand_path(File.dirname(__FILE__) + '/..')
-$:.unshift File.join(jetpants_base_dir, 'lib')
 %w[thor pry highline/import colored].each {|g| require g}
 
 module Jetpants
@@ -109,7 +107,7 @@ module Jetpants
       
       error "Unable to determine a node to demote and a node to promote" unless demoted.kind_of?(Jetpants::DB) && promoted.kind_of?(Jetpants::DB)
       error "Node to promote #{promoted} is not a slave of node to demote #{demoted}" unless promoted.master == demoted
-      error "Cannot promote a backup slave. Please choose another." if promoted.for_backups?
+      error "The chosen node cannot be promoted. Please choose another." unless promoted.promotable_to_master?
       
       inform "Going to DEMOTE existing master #{demoted} and PROMOTE new master #{promoted}."
       error "Aborting." unless agree "Proceed? [yes/no]: "
@@ -124,12 +122,20 @@ module Jetpants
     
     
     desc 'summary', 'display information about a node in the context of its pool'
-    method_option :node, :desc => 'IP address of node to query'
+    method_option :node, :desc => 'IP address of node to query, or name of pool'
     def summary
-      node = ask_node('Please enter node IP: ', options[:node])
-      node.pool(true).probe
-      describe node
-      node.pool(true).summary(true)
+      node = options[:node] || ask('Please enter node IP or name of pool: ')
+      if is_ip? node
+        node = node.to_db
+        node.pool(true).probe
+        describe node
+        node.pool(true).summary(true)
+      else
+        pool = Jetpants.topology.pool(node)
+        raise "#{node} is neither an IP address nor a pool name" unless pool
+        pool.probe
+        pool.summary(true)
+      end
     end
     
     
@@ -140,7 +146,7 @@ module Jetpants
       Jetpants.pools.each &:summary
       
       # We could do this more compactly using DB#role, but it would incorrectly
-      # handle counts for shards in the middle of a split
+      # double-count nodes involved in a shard split
       counts = {master: 0, active_slave: 0, standby_slave: 0, backup_slave: 0}
       Jetpants.pools.each do |p|
         counts[:master] += 1
@@ -170,10 +176,10 @@ module Jetpants
     def pools_compact
       puts
       Jetpants.shards.each do |s| 
-        puts "[%-15s] %8s to %-11s = %3s GB" % [s.ip, s.min_id, s.max_id, s.data_set_size(true)]
+        puts "[%-15s] %8s to %-11s = %4s GB" % [s.ip, s.min_id, s.max_id, s.data_set_size(true)]
       end
       Jetpants.functional_partitions.each do |p| 
-        puts "[%-15s] %-23s = %3s GB" % [p.ip, p.name, p.data_set_size(true)]
+        puts "[%-15s] %-23s = %4s GB" % [p.ip, p.name, p.data_set_size(true)]
       end
       puts
     end
@@ -187,17 +193,32 @@ module Jetpants
     
     desc 'clone_slave', 'clone a standby slave'
     method_option :source, :desc => 'IP of node to clone from'
-    method_option :target, :desc => 'IP of node to clone to'
+    method_option :target, :desc => 'IP of node(s) to clone to'
     def clone_slave
       puts "This task clones the data set of a standby slave."
       source = ask_node('Please enter IP of node to clone from: ', options[:source])
+      source.master.probe if source.master # fail early if there are any replication issues in this pool
       describe source
       
-      target = options[:target] || ask('Please enter comma-separated list of IP addresses to clone to: ')
+      puts "You may clone to particular IP address(es), or can type \"spare\" to claim a node from the spare pool."
+      target = options[:target] || ask('Please enter comma-separated list of targets (IPs or "spare") to clone to: ')
+      target = 'spare' if target.strip == '' || target.split(',').length == 0
+      spares_needed = target.split(',').count {|t| t.strip.upcase == 'SPARE'}
+      if spares_needed > 0
+        spares_available = Jetpants.topology.count_spares(role: :standby_slave, like: source)
+        raise "Not enough spare machines with role of standby slave! Requested #{spares_needed} but only have #{spares_available} available." if spares_needed > spares_available
+        claimed_spares = Jetpants.topology.claim_spares(spares_needed, role: :standby_slave, like: source)
+      end
+
       targets = target.split(',').map do |ip|
         ip.strip!
-        error "target (#{ip}) does not appear to be an IP." unless is_ip? ip
-        ip.to_db
+        if is_ip? ip
+          ip.to_db
+        elsif ip == '' || ip.upcase == 'SPARE'
+          claimed_spares.shift
+        else
+          error "target (#{ip}) does not appear to be an IP."
+        end
       end
       
       source.start_mysql if ! source.running?
@@ -205,6 +226,7 @@ module Jetpants
       
       targets.each do |t|
         error "target #{t} already has a master; please clear out node (including in asset tracker) before proceeding" if t.master
+        error "target #{t} is running a different version of MySQL than source #{source}! Cannot proceed with clone operation." if t.version_cmp(source) != 0
       end
       
       source.enslave_siblings!(targets)
@@ -213,11 +235,6 @@ module Jetpants
       puts "Cloning complete."
       Jetpants.topology.write_config
     end
-    def self.after_clone_slave
-      reminders(
-        'Add the new host(s) to trending and monitoring.'
-      )
-    end
     
     
     desc 'activate_slave', 'turn a standby slave into an active slave'
@@ -256,18 +273,26 @@ module Jetpants
     desc 'destroy_slave', 'remove a standby slave from its pool'
     method_option :node, :desc => 'IP of standby slave to remove'
     def destroy_slave
+      # Permit slaves with broken replication to be destroyed
+      Jetpants.verify_replication = false
       puts "This task removes a standby/backup slave from its pool entirely. THIS IS PERMANENT, ie, it does a RESET SLAVE on the target."
       node = ask_node('Please enter node IP: ', options[:node])
       describe node
-      raise "Node is not a standby or backup slave" unless (node.is_standby? || node.for_backups?)
+      if node.running? && node.available?
+        raise "Node is not a standby or backup slave" unless (node.is_standby? || node.for_backups?)
+      else
+        puts "Please note that we cannot run a RESET SLAVE on the node, because MySQL is not running or is otherwise unreachable."
+        puts "If the node is not permanently dead, you will have to run this manually."
+      end
       raise "Aborting" unless ask('Please type YES in all capital letters to confirm removing node from its pool: ') == 'YES'
       node.pool.remove_slave!(node)
+      node.revoke_all_access!
     end
     
     
     desc 'defrag_slave', 'export and re-import data set on a standby slave'
     method_option :node, :desc => 'IP of standby slave to defragment'
-    def rebuild_slave
+    def defrag_slave
       puts "This task exports all data on a standby/backup slave and then re-imports it."
       node = ask_node('Please enter node IP: ', options[:node])
       describe node
@@ -358,7 +383,6 @@ module Jetpants
     end
     def self.after_shard_split
       reminders(
-        'Trending and monitoring setup, as needed.',
         'Proceed to next step: jetpants shard_split_child_reads'
       )
     end
@@ -415,16 +439,25 @@ module Jetpants
     desc 'shard_cutover', 'truncate the current last shard range, and add a new shard after it'
     method_option :cutover_id, :desc => 'Minimum ID of new last shard being created'
     def shard_cutover
-      # ensure the spares are available before beginning
-      raise "Not enough total spare machines!" unless Jetpants.topology.count_spares >= Jetpants.standby_slaves_per_pool + 1
-      raise "Not enough standby_slave role spare machines!" unless Jetpants.topology.count_spares(role: 'standby_slave') >= Jetpants.standby_slaves_per_pool
-      raise "Cannot find a spare master-role machine!" unless Jetpants.topology.count_spares(role: 'master') >= 1
-
       cutover_id = options[:cutover_id] || ask('Please enter min ID of the new shard to be created: ')
       cutover_id = cutover_id.to_i
       last_shard = Jetpants.topology.shards.select {|s| s.max_id == 'INFINITY' && s.in_config?}.first
       last_shard_master = last_shard.master
       
+      # Simple sanity-check that the cutover ID is greater than the current last shard's MIN id.
+      # (in a later release, this may be improved to also ensure it's greater than any sharding
+      # key value in use on the last shard.)
+      raise "Specified cutover ID is too low!" unless cutover_id > last_shard.min_id
+      
+      # Ensure enough spare nodes are available before beginning.
+      # We supply the *previous* last shard as context for counting/claiming spares
+      # because the new last shard can't be created yet (chicken-and-egg problem -- master
+      # must exist before we create the pool). The assumption is the hardware spec
+      # of the new last shard and previous last shard will be the same.
+      raise "Not enough total spare machines!" unless Jetpants.topology.count_spares(like: last_shard_master) >= Jetpants.standby_slaves_per_pool + 1
+      raise "Not enough standby_slave role spare machines!" unless Jetpants.topology.count_spares(role: :standby_slave, like: last_shard_master) >= Jetpants.standby_slaves_per_pool
+      raise "Cannot find a spare master-role machine!" unless Jetpants.topology.count_spares(role: :master, like: last_shard_master) >= 1
+      
       # In asset tracker, remove the last shard pool and replace it with a new pool. The new pool
       # has the same master/slaves but now has a non-infinity max ID.
       last_shard.state = :recycle
@@ -433,11 +466,13 @@ module Jetpants
       last_shard_replace.sync_configuration
       Jetpants.topology.pools << last_shard_replace
       
-      # Now put another new shard after that one
-      new_last_shard_master = Jetpants.topology.claim_spare(role: 'master')
-      new_last_shard_master.disable_read_only! if (new_last_shard_master.running? && new_last_shard_master.read_only?)
+      # Now put another new shard after that one. (See earlier comment as to why we're supplying
+      # the pool from the old last shard. This param is just used to select the right type of hardware,
+      # NOT to actually set the pool of the returned object.)
+      new_last_shard_master = Jetpants.topology.claim_spare(role: :master, like: last_shard_master)
+      new_last_shard_master.disable_read_only! if new_last_shard_master.running?
       if Jetpants.standby_slaves_per_pool > 0
-        new_last_shard_slaves = Jetpants.topology.claim_spares(Jetpants.standby_slaves_per_pool, role: 'standby_slave')
+        new_last_shard_slaves = Jetpants.topology.claim_spares(Jetpants.standby_slaves_per_pool, role: :standby_slave, like: last_shard_master)
         new_last_shard_slaves.each do |x| 
           x.change_master_to new_last_shard_master
           x.resume_replication
@@ -458,7 +493,6 @@ module Jetpants
     end
     def self.after_shard_cutover
       reminders(
-        'Trending and monitoring setup, as needed.',
         'Commit/push the configuration in version control.',
         'Deploy the configuration to all machines.',
       )

data/doc/commands.rdoc

@@ -16,6 +16,8 @@ The copy method in \Jetpants uses a combination of tar, netcat (nc), and whichev
 
 This command does not require an asset tracker plugin, but DOES require that all your database nodes have installed whichever compression binary you specified in the Jetpants config file.
 
+If you are using an asset tracker, when prompted for which nodes to clone TO, you may type "spare" (or equivalently just hit ENTER without typing any input) to claim a spare node with role STANDBY_SLAVE. You may clone to multiple spares at once by supplying comma-separated input like "spare, spare, spare". You can mix-and-match with supplying IP addresses of particular hosts as well.
+
 
 == Master/slave state changes
 

data/doc/configuration.rdoc

@@ -4,13 +4,13 @@
 
 At least one of these files must exist for \Jetpants to function properly.
 
-If both exist, the user configuration will be merged on top of the global configuration, but please note that this is not a "deep" merge. So if the user configuration defines a "plugins" section, this will used as-is and the global "plugins" section will be ignored. This may change in a future release.
+If both exist, the user configuration will be merged on top of the global configuration, this is a "deep" merge. So if the user a "plugins" section this will be combined with the global "plugins" section.
 
 For an example global configuration file, please see the included <tt>etc/jetpants.yaml.sample</tt> file.
 
 == Configuration settings
 
-max_concurrency::           Maximum threads to use in import/export operations, or equivalently the maximum connection pool size per database host (default: 40)
+max_concurrency::           Maximum threads to use in import/export operations, or equivalently the maximum connection pool size per database host. You will need to tune this to your specific database hardware, especially number of CPU cores and number/type of disks (default: 20)
 standby_slaves_per_pool::   Minimum number of standby slaves to keep in every pool (default: 2)
 mysql_schema::              database name (mandatory)
 mysql_app_user::            mysql user that your application uses (mandatory)
@@ -24,6 +24,7 @@ compress_with::             command line to perform compression during large fil
 decompress_with::           command line to perform decompression during large file copy operations; see below (default: false)
 export_location::           directory to use for data dumping (default: '/tmp')
 verify_replication::        raise exception if the actual replication topology differs from Jetpants' understanding of it (ie, disagreement between asset tracker and probed state), or if MySQL's two replication threads are in different states (one running and the other stopped) on a DB node. (default: true. master promotion tool ignores this, since the demoted master may legitimately be dead/offline)
+private_interface::         name of private interface on your servers, such as eth0 or bond0. Not used by any core \Jetpants commands, but can be useful in plugings that wrap tcpdump, or code calling the Jetpants::Host.local method. (default: 'bond0')
 plugins::                   hash of plugin name => arbitrary plugin data, usually a nested hash of settings (default: \{})
 ssh_keys::                  array of SSH private key file locations, if not using standard id_dsa or id_rsa. Passed directly to Net::SSH.start's :keys parameter (default: nil)
 sharded_tables::            array of name => \{sharding_key=>X, chunks=>Y} hashes, describing all tables on shards. Required by shard split/rebuild processes (default: \[])

data/doc/jetpants_collins.rdoc

@@ -38,7 +38,7 @@ This plugin also makes some assumptions about the way in which you use \Collins,
 * All MySQL database server hosts that are in-use will have a STATUS of either ALLOCATED or MAINTENANCE.
 * All MySQL database server hosts that are in-use will have a POOL set matching the name of their pool/shard, and a SECONDARY_ROLE set matching their \Jetpants role within the pool (MASTER, ACTIVE_SLAVE, STANDBY_SLAVE, or BACKUP_SLAVE).
 * You can initially assign PRIMARY_ROLE, STATUS, POOL, and SECONDARY_ROLE to database servers somewhat automatically; see GETTING STARTED, below.
-* All database server hosts that are "spares" (not yet in use, but ready for use in shard splits, shard cutover, or slave cloning) need to have a STATUS of PROVISIONED. These nodes must meet the requirements of spares as defined by the REQUIREMENTS doc that comes with \Jetpants. They should NOT have a POOL set, but they may have a ROLE set to either MASTER or STANDBY_SLAVE. The role will be used to select spare nodes for shard splits and shard cutover.
+* All database server hosts that are "spares" (not yet in use, but ready for use in shard splits, shard cutover, or slave cloning) need to have a STATUS of PROVISIONED. These nodes must meet the requirements of spares as defined by the REQUIREMENTS doc that comes with \Jetpants. They should NOT have a POOL or SECONDARY_ROLE set in advance; if they do, it will be ignored -- we treat all spares as identical. That said, you can implement custom logic to respect POOL or SECONDARY_ROLE (or any other Collins attribute) by overriding Topology#process_spare_selector_options in a custom plugin loaded after jetpants_collins.
 * Database server hosts may optionally have an attribute called SLAVE_WEIGHT. The default weight, if omitted, is 100. This field has no effect in \Jetpants, but can be used by your custom configuration generator as needed, if your application supports a notion of different weights for slave selection.
 * Arbitrary metadata regarding pools and shards will be stored in assets with a TYPE of CONFIGURATION. These assets will have a POOL matching the pool's name, a TAG matching the pool's name but prefixed with 'mysql-', a STATUS reflecting the pool's state, and a PRIMARY_ROLE of either MYSQL_POOL or MYSQL_SHARD depending on the type of pool. You can make jetpants_collins create these automatically; see GETTING STARTED, below.
 

data/doc/plugins.rdoc

@@ -56,6 +56,10 @@ You may also want to override or implement these, though it's not strictly manda
 * Jetpants::Pool#after_remove_slave!
   * If your implementation of Jetpants::Pool#sync_configuration works by iterating over the current slaves of the pool's master, it won't correctly handle the <tt>jetpants destroy_slave</tt> command,
     or anything else that calls Jetpants::DB#disable_replication! which does a RESET SLAVE. You can instead handle that special case here.
+* Jetpants::DB#stop_query_kiler and Jetpants::DB#start_query_killer
+  * If you use a query killer, you'll want to override these methods to start and stop it. stop_query_killer is called prior to a long-running query (SELECT ... INTO OUTFILE, LOAD DATA INFILE, SELECT COUNT(*), etc) and start_query_killer is called after the operation is complete.
+* Jetpants::DB#disable_monitoring and Jetpants::DB#enable_monitoring
+  * If you use monitoring software, you can override these methods to prevent alerts from \Jetpants operations. \Jetpants calls disable_monitoring prior to performing maintenance operations on a node, such as stopping MySQL prior to cloning a slave, splitting a shard, etc. It calls enable_monitoring once the operation is complete.
 
 == How to write a plugin
 

data/doc/requirements.rdoc

@@ -14,7 +14,7 @@ Plugins may freely override these assumptions, and upstream patches are very wel
   * For example, \jetpants requires the mysql2 gem, which in turn needs MySQL development C headers in order to compile.
 * MySQL (or compatible, like Percona Server), version 5.1 or higher.
 * Required Linux binaries that must be installed and in root's PATH on all of your database machines:
-  * <tt>service</tt>, a wrapper around init scripts, supporting syntax <tt>service mysql start</tt>, <tt>service mysql status</tt>, etc. Some distros include this by default (typically as /sbin/service or /usr/sbin/service) while others offer it as a package. Implementation varies slightly between distros; currently \Jetpants expects <tt>service mysql status</tt> output to include either "not running" (RHEL/Centos) or "stop/waiting" (Ubuntu) in the output if the MySQL server is not running.
+  * <tt>service</tt>, a wrapper around init scripts, supporting syntax <tt>service mysql start</tt>, <tt>service mysql status</tt>, etc. Some distros include this by default (typically as /sbin/service or /usr/sbin/service) while others offer it as a package. Implementation varies slightly between distros; currently \Jetpants expects <tt>service mysql status</tt> output to include either "not running" (RHEL/Centos) or "stop/waiting" (Ubuntu) in the output if the MySQL server is not running. Additionally, <tt>service</tt> must pass extra parameters through to the daemon -- <tt>service mysql start --skip-networking</tt> should pass <tt>--skip-networking</tt> to mysqld.
   * <tt>nc</tt>, also known as netcat, a tool for piping data to or from a socket.
   * Whichever compression tool you've specified in the \Jetpants config file for the <tt>compress_with</tt> and <tt>decompress_with</tt> options, if any. (if omitted, compression will not be used for file copy operations.)
 * InnoDB / Percona XtraDB for storage engine. \Jetpants has not been tested with MyISAM, since \Jetpants is geared towards huge tables, and MyISAM is generally a bad fit.

data/lib/jetpants.rb

@@ -21,7 +21,7 @@ module Jetpants
   # Establish default configuration values, and then merge in whatever we find globally
   # in /etc/jetpants.yaml and per-user in ~/.jetpants.yaml
   @config = {
-    'max_concurrency'         =>  40,         # max threads/conns per database
+    'max_concurrency'         =>  20,         # max threads/conns per database
     'standby_slaves_per_pool' =>  2,          # number of standby slaves in every pool
     'mysql_schema'            =>  'test',     # database name
     'mysql_app_user'          =>  'appuser',  # mysql user for application
@@ -38,10 +38,27 @@ module Jetpants
     'sharded_tables'          =>  [],         # array of name => {sharding_key=>X, chunks=>Y} hashes
     'compress_with'           =>  false,      # command line to use for compression in large file transfers
     'decompress_with'         =>  false,      # command line to use for decompression in large file transfers
+    'private_interface'       =>  'bond0',    # network interface corresponding to private IP
   }
-  %w(/etc/jetpants.yaml ~/.jetpants.yml ~/.jetpants.yaml).each do |path|
-    overrides = YAML.load_file(File.expand_path path) rescue {}
-    @config.merge! overrides
+
+  config_paths = ["/etc/jetpants.yaml", "~/.jetpants.yml", "~/.jetpants.yaml"]
+  config_loaded = false
+
+  config_paths.each do |path|
+    begin
+      overrides = YAML.load_file(File.expand_path path)
+      @config.deep_merge! overrides
+      config_loaded = true
+    rescue Errno::ENOENT => error
+    rescue ArgumentError => error
+      puts "YAML parsing error in configuration file #{path} : #{error.message}\n\n"
+      exit
+    end
+  end
+
+  unless config_loaded
+    puts "Could not find any readable configuration files at either /etc/jetpants.yaml or ~/.jetpants.yaml\n\n"
+    exit
   end
   
   class << self

data/lib/jetpants/db.rb

@@ -66,6 +66,10 @@ module Jetpants
       # These get set upon DB#connect being run
       @user = nil
       @schema = nil
+      
+      # This is ephemeral, only known to Jetpants if you previously called
+      # DB#start_mysql or DB#restart_mysql in this process
+      @options = []
     end
     
     ###### Host methods ########################################################

data/lib/jetpants/db/client.rb

@@ -41,14 +41,19 @@ module Jetpants
     # Initializes (or re-initializes) the connection pool upon first use or upon
     # requesting a different user or schema. Note that we only maintain one connection
     # pool per DB.
-    # Valid options include :user, :pass, :schema, :max_conns or omit these to use
-    # defaults.
+    # Valid options include :user, :pass, :schema, :max_conns, :after_connect or omit
+    # these to use defaults.
     def connect(options={})
+      if @options.include? '--skip-networking'
+        output 'Skipping connection attempt because server started with --skip-networking'
+        return nil
+      end
+      
       options[:user]    ||= app_credentials[:user]
       options[:schema]  ||= app_schema
       
       return @db if @db && @user == options[:user] && @schema == options[:schema]
-
+      
       disconnect if @db
       
       @db = Sequel.connect(
@@ -58,7 +63,8 @@ module Jetpants
         :user             =>  options[:user],
         :password         =>  options[:pass] || app_credentials[:pass],
         :database         =>  options[:schema],
-        :max_connections  =>  options[:max_conns] || Jetpants.max_concurrency)
+        :max_connections  =>  options[:max_conns] || Jetpants.max_concurrency,
+        :after_connect    =>  options[:after_connect] )
       @user = options[:user]
       @schema = options[:schema]
       @db

data/lib/jetpants/db/import_export.rb

@@ -101,14 +101,29 @@ module Jetpants
     # run after export_data (in the same process), import_data will 
     # automatically confirm that the import counts match the previous export
     # counts.
+    #
     # Creates a 'jetpants' db user with FILE permissions for the duration of the
     # import.
+    #
+    # Note: import will be substantially faster if you disable binary logging
+    # before the import, and re-enable it after the import. You also must set
+    # InnoDB's autoinc lock mode to 2 in order to do a chunked import with
+    # auto-increment tables.  You can achieve all this by calling
+    # DB#restart_mysql '--skip-log-bin', '--skip-log-slave-updates', '--innodb-autoinc-lock-mode=2'
+    # prior to importing data, and then clear those settings by calling
+    # DB#restart_mysql with no params after done importing data.
     def import_data(tables, min_id=false, max_id=false)
+      disable_read_only!
       import_export_user = 'jetpants'
       create_user(import_export_user)
       grant_privileges(import_export_user)               # standard privs
       grant_privileges(import_export_user, '*', 'FILE')  # FILE global privs
-      reconnect(user: import_export_user)
+      
+      # Disable unique checks upon connecting. This has to be done at the :after_connect level in Sequel
+      # to guarantee it's being run on every connection in the conn pool. This is mysql2-specific.
+      disable_unique_checks_proc = Proc.new {|mysql2_client| mysql2_client.query 'SET unique_checks = 0'}
+      
+      reconnect(user: import_export_user, after_connect: disable_unique_checks_proc)
       
       import_counts = {}
       tables.each {|t| import_counts[t.name] = import_table_data t, min_id, max_id}
@@ -258,9 +273,7 @@ module Jetpants
       
       disable_monitoring
       stop_query_killer
-      disable_binary_logging
-      restart_mysql
-      pause_replication if is_slave?
+      restart_mysql '--skip-log-bin', '--skip-log-slave-updates', '--innodb-autoinc-lock-mode=2', '--skip-slave-start'
       
       # Automatically detect missing min/max. Assumes that all tables' primary keys
       # are on the same scale, so this may be non-ideal, but better than just erroring.
@@ -283,11 +296,9 @@ module Jetpants
       import_schemata!
       alter_schemata if respond_to? :alter_schemata
       import_data tables, min_id, max_id
-
-      resume_replication if is_slave?
-      enable_binary_logging
+      
       restart_mysql
-      catch_up_to_master
+      catch_up_to_master if is_slave?
       start_query_killer
       enable_monitoring
     end
@@ -303,15 +314,21 @@ module Jetpants
       destinations = {}
       targets.each do |t| 
         destinations[t] = t.mysql_directory
-        existing_size = t.data_set_size + t.dir_size("#{t.mysql_directory}/ibdata1")
-        raise "Over 100 MB of existing MySQL data on target #{t}, aborting copy!" if existing_size > 100000000
+        raise "Over 100 MB of existing MySQL data on target #{t}, aborting copy!" if t.data_set_size > 100000000
       end
       [self, targets].flatten.concurrent_each {|t| t.stop_query_killer; t.stop_mysql}
       targets.concurrent_each {|t| t.ssh_cmd "rm -rf #{t.mysql_directory}/ib_logfile*"}
+      
+      # Construct the list of files and dirs to copy. We include ib_lru_dump if present
+      # (ie, if using Percona Server with innodb_buffer_pool_restore_at_startup enabled)
+      # since this will greatly improve warm-up time of the cloned nodes
+      files = ['ibdata1', 'mysql', 'test', app_schema]
+      files << 'ib_lru_dump' if ssh_cmd("test -f #{mysql_directory}/ib_lru_dump 2>/dev/null; echo $?").chomp.to_i == 0
+      
       fast_copy_chain(mysql_directory, 
                       destinations,
                       port: 3306,
-                      files: ['ibdata1', 'mysql', 'test', app_schema],
+                      files: files,
                       overwrite: true)
       [self, targets].flatten.concurrent_each {|t| t.start_mysql; t.start_query_killer}
     end