repctl 0.0.2 → 0.0.3

data/README.md

@@ -25,6 +25,9 @@ MySQL from source, then do `make install`, then you are done!  No MySQL
 post-installation steps are necessary.  All post-install configuration is
 handled by `repctl`.
 
+You will need to set an environment variable `REPCTL_CONFIG_DIR` in your shell
+so that `repctl` can find the configuration files it needs.  
+
 The top
 
 == Available Commands

data/bin/repctl

@@ -1,195 +1,189 @@
 #!/usr/bin/env ruby
 
 require 'socket'
+require 'fileutils'
 require 'repctl'
 require 'thor'
 
-# Thor has the 'helpful' property that any Thor task gets executed only
-# once.  The 'Helpers' module makes many Thor tasks available as ordinary
-# Ruby functions for internal use.  The corresponding Thor tasks usually
-# delegate to the corresponding helper function with 'super'.
-module Helpers
-  
-  include Repctl::Config
-  include Repctl::Servers
-  
-  def start(instance)
-    say "Starting instance #{instance}.", :green
-    do_start(instance)
-  end
-  
-  def start_all
-    all_instances.each do |instance|
-      start(instance)
-    end
-  end
-  
-  def stop(instance)
-    say "Stopping instance #{instance}.", :green
-    do_admin(instance, "shutdown")
-  end
-  
-  def stop_all
-    all_live_instances.each do |instance|
-      stop(instance)
+module Repctl
+  module Helpers
+    def do_stop(instance)
+      do_admin(instance, "shutdown")
     end
-  end
-  
-  def config(instance)
-    say "Initializing new data directory for instance #{instance}."
-    do_config(instance)
-  end
-  
-  def config_all
-    all_instances.each do |instance|
-       config(instance)
-     end
-  end
-
-  def secure_accounts(instance)
-    do_secure_accounts(instance)
-  end
 
-  def secure_accounts_all
-    Repctl::Servers.all_live_instances.each do |instance|
-       secure_accounts(instance)
-     end
-  end
-  
-  def reset(instance)
-    stop(instance)
-    config(instance)
-    start(instance)
-    secure_accounts(instance)
-  end
- 
-  def restart(instance)
-    stop(instance)
-    start(instance)
-  end
-
-  def reset_all
-    all_instances.each do |instance|
-       reset(instance)
-     end
-  end
-  
-  def change_master(master, slave, file, position)
-    say "Changing master: master = #{master}, slave = #{slave}, file = #{file}, position = #{position}"
-    do_change_master(master, slave, :file => file, :position => position)
-  end
-      
-  def start_slave(slave)
-    say "Starting slave #{slave}", :green
-    run_mysql_query(slave, "START SLAVE")
-  end
-  
-  def crash(instance)
-    say "Crashing instance #{instance}", :red
-    do_crash(instance)
-  end
+    def do_reset(instance)
+      do_stop(instance)
+      do_config(instance)
+      do_start(instance)
+      do_secure_accounts(instance)
+    end
 
-  def repl_user(instance)
-    say "Creating replication account on instance #{instance}.", :green
-    do_repl_user(instance)
-  end
+    def do_start_slave(instance)
+      run_mysql_query(instance, "START SLAVE")
+    end
 
-  def cluster_user(instance = 1)
-    say "Installing cluster user for instance #{instance}.", :green
-    do_cluster_user(instance)
+    def do_restart(instance)
+      do_admin(instance, "shutown")
+      do_start(instance)
+    end
   end
-      
-end # Module helpers
+end
 
-class Mysql < Thor
+class RepctlCmds < Thor
 
   include Thor::Actions
   include Repctl::Config
   include Repctl::Commands
   include Repctl::Servers
-  include Helpers
-  
-  desc "start INSTANCE", "Ensure that the given MySQL server instance is running."
-  def start(instance)
-    super
-  end
-  
-  desc "start_all", "Start all the MySQL instances."
-  def start_all
-    super
-  end
-  
-  desc "stop INSTANCE", "Stop a running MySQL server instance."
-  def stop(instance)
-    super
+  include Repctl::Helpers
+
+  desc "start [INSTANCES]", "Start one or more defined server instances."
+  method_option :all, :type  => :boolean, :aliases => "-a",
+    :default => false,  :desc => "Start all defined instances"
+  long_desc <<-EOS
+    Start one or more defined server instances.  With the --all option, 
+    all defined servers are started.  Otherwise, you can give a list of
+    servers to start.  If a server instance is already running, this
+    command has no effect on the instance.
+  EOS
+  def start(*instances)
+    if options[:all]
+      todos = all_instances
+    else
+      todos = instances
+    end
+    todos.each do |instance|
+      say "Starting instance #{instance}.", :green
+      do_start(instance)
+    end
   end
   
-  desc "stop_all", "Stop all the MySQL servers."
-  def stop_all
-    super
+  desc "stop [INSTANCES]", "Stop one or more running server instances."
+  method_option :all, :type  => :boolean, :aliases => "-a",
+    :default => false,  :desc => "Stop all running instances"
+  long_desc <<-EOS
+    Stop one or more running server instances.  With the --all option, 
+    all running servers are stopped.  Otherwise, you can give a list of
+    servers to stop.
+  EOS
+  def stop(*instances)
+    if options[:all]
+      todos = all_live_instances
+    else
+      todos = instances
+    end
+    todos.each do |instance|
+      say "Stopping instance #{instance}.", :green
+      do_stop(instance)
+    end
   end
   
-  desc "config INSTANCE", "Initialize the data directory for a new instance."
-  def config(instance)
-    super
+  desc "config [INSTANCES]", "Initialize the data directory for server instances."
+  method_option :all, :type  => :boolean, :aliases => "-a",
+    :default => false,  :desc => "Initialize all defined instances"
+  long_desc <<-EOS
+    Initialize the data directory for one or more server instances.
+    With the --all option, the data directory for all defined servers
+    is initialized. Otherwise, you can give a list of defined server
+    instances.
+  EOS
+  def config(*instances)
+    if options[:all]
+      todos = all_instances
+    else
+      todos = instances
+    end
+    todos.each do |instance|
+    say "Initializing new data directory for instance #{instance}.", :green
+      do_config(instance)
+    end
   end
-  
-  desc "config_all", "Initialize the data directories for all instances."
-  def config_all
-    super
-  end 
-  
-  desc "secure_accounts INSTANCE", "Add passwords for root and anonymous accounts."
-  def secure_accounts(instance)
-    super
+
+  desc "secure_accounts [INSTANCES]", "Add password to root and anonymous accounts."
+  method_option :all, :type  => :boolean, :aliases => "-a",
+    :default => false,  :desc => "Secure accounts for  all running instances"
+  long_desc <<-EOS
+    Add a password to the existing root and anonymous accounts of one or more
+    running server instances.  With the --all option, all running servers
+    secured.  Otherwise, you can give a list of servers to process.
+  EOS
+  def secure_accounts(*instances)
+    if options[:all]
+      todos = all_live_instances
+    else
+      todos = instances
+    end
+    todos.each do |instance|
+      say "Securing accounts for instance #{instance}.", :green
+      do_secure_accounts(instance)
+    end
   end
 
-  desc "secure_accounts_all", "Add passwords for root and anonymous accounts for all instances."
-  def secure_accounts_all
-    super
+  desc "reset [INSTANCES]", "Reset one or more define server instances."
+  method_option :all, :type  => :boolean, :aliases => "-a",
+    :default => false,  :desc => "Reset all defined instances"
+  long_desc <<-EOS
+    Reset one or more defined server instances. If the --all option is
+    given the target servers are all defined servers, otherwise the
+    target servers are those specified in the instance argument.
+    If a target server instance is running, stop it.  Then configure its
+    data directory, (re)start the server, and secure the accounts.
+  EOS
+  def reset(*instances)
+    if options[:all]
+      todos = all_instances
+    else
+      todos = instances
+    end
+    todos.each do |instance|
+      say "Resetting instance #{instance}.", :green
+      do_reset(instance)
+    end
   end
   
-  desc "reset", "Remove the database data directory, reconfigure and restart the instance."
-  def reset(instance)
-    super
+  desc "restart INSTANCE"  , "Stop and start a server instance."
+  def restart(instance)
+    say "Restarting instance #{instance}", :green
+    do_stop(instance)
+    do_start(instance)
   end
 
-  desc "reset_all", "Remove all databases and restart MySQL instances."
-  def reset_all
-    super
-  end
-  
   desc "start_slave SLAVE", "Issue START SLAVE on the SLAVE MySQL instance."
   def start_slave(slave)
-    super
+    say "Starting slave #{slave}", :green
+    do_start_slave(slave)
   end
   
   desc "change_master MASTER SLAVE FILE POSITION", "Execute CHANGE MASTER TO on the SLAVE."
   def change_master(master, slave, file, position)
-    super
+    say "Changing master: master = #{master}, slave = #{slave}, file = #{file}, position = #{position}"
+    do_change_master(master, slave, :file => file, :position => position)
   end
   
-  desc "crash INSTANCE", "Crash a running MySQL server."
+  desc "crash INSTANCE", "Crash a running server."
   def crash(instance)
-    super
+    say "Crashing instance #{instance}", :red
+    do_crash(instance)
   end
   
   desc "repl_user INSTANCE", "Create the replication user account on a MySQL instance."
   def repl_user(instance)
-    super
+    say "Creating replication account on instance #{instance}.", :green
+    do_repl_user(instance)
   end
   
   desc "cluster_user INSTANCE", "Create the cluster user account on a MySQL instance."
   def cluster_user(instance)
-    super
+    say "Installing cluster user for instance #{instance}.", :green
+    do_cluster_user(instance)
   end
-  
-  desc "repl_status", "Show the status of replication."
+
+  desc "status", "Show the status of replication."
    method_option :continuous, :aliases => "-c", :type => :numeric,
     :desc => "Continuous output at specified interval (in seconds)."
   method_option :servers, :aliases => "-s", :type => :array,
     :desc => "Only check the status of given servers."
-  def repl_status
+  def status
     todos = options[:servers] || all_live_instances
     unless todos.any?
       say "No Running Servers.", :blue
@@ -250,9 +244,31 @@ class Mysql < Thor
   def restore(slave, dumpfile = DEFAULT_DUMPFILE)
     do_restore(slave, dumpfile)
   end
-  
+
+  #
+  # Setting Up Replication with Existing Data using the 'mysqldump' utility. The
+  # master has existing data.
+  #
+  desc "add_slave MASTER SLAVE", "Master has some data that is used to initialize the slave."
+  method_option :populate, :type => :boolean, :default => false
+  def add_slave(master, slave)
+    reset(slave)
+    
+    if options[:populate]
+      invoke "utils:bench", [master, "/opt/MySQL/b2.properties"]
+    end
+    file, position = invoke "mysql:dump", [master]
+    
+    # Slave is running, but it is not yet configured as a slave.
+    # Load slave from the dump file...
+    invoke "mysql:restore", [slave]
+    
+    do_change_master(master, slave, :file => file, :position => position)
+    do_start_slave(slave)
+  end
+
   DEFAULT_MASTER = 1
-  
+
   desc "bench [INSTANCE] [PROPS]", "Run the Tungsten Bristlecone benchmarker.
   The INSTANCE specifies the instance to perform all operations to, and PROPS
   is the properties file to use. The INSTANCE defaults to #{DEFAULT_MASTER} and
@@ -334,9 +350,8 @@ class Mysql < Thor
       msecs = options[:delay]
       sleep(msecs / 1000.0) if msecs > 0
     end
-    
   end
-  
+
   #
   # Setting Up Replication with New Master and Slaves.
   # Here, we stop all MySQL servers, remove the data directories, reinitialize
@@ -347,16 +362,16 @@ class Mysql < Thor
     "Set up a single master/slave replication pair from the very beginning."
   def repl_pair(master, slave)
     say "master is #{master}, slave is #{slave}", :green
-    reset(master)
-    reset(slave)
-    cluster_user(master)
-    repl_user(master)
+    do_reset(master)
+    do_reset(slave)
+    do_cluster_user(master)
+    do_repl_user(master)
     coordinates = get_coordinates(master)
     file = coordinates[:file]
     position = coordinates[:position]
     say "File is #{file}, Position is #{position}", :green
-    change_master(master, slave, file, position)
-    start_slave(slave)
+    do_change_master(master, slave, :file => file, :position => position)
+    do_start_slave(slave)
   end
 
   desc "repl_trio MASTER SLAVE1 SLAVE2",
@@ -365,48 +380,41 @@ class Mysql < Thor
   def repl_trio(master, slave1, slave2)
     say "master is #{master}, slaves are #{slave1} and #{slave2}", :green
     if options[:reset]
-      reset(master)
-      reset(slave1)
-      reset(slave2)
-      cluster_user(master)
-      repl_user(master)
+      do_reset(master)
+      do_reset(slave1)
+      do_reset(slave2)
+      do_cluster_user(master)
+      do_repl_user(master)
     else
-      restart(master)
-      restart(slave1)
-      restart(slave2)
+      do_restart(master)
+      do_restart(slave1)
+      do_restart(slave2)
     end
     coordinates = get_coordinates(master)
     file = coordinates[:file]
     position = coordinates[:position]
     say "File is #{file}, Position is #{position}", :green
-    change_master(master, slave1, file, position)
-    start_slave(slave1)
-    change_master(master, slave2, file, position)
-    start_slave(slave2)
+    do_change_master(master, slave1, :file => file, :position => position)
+    do_start_slave(slave1)
+    do_change_master(master, slave2, :file => file, :position => position)
+    do_start_slave(slave2)
   end
-    
-  #
-  # Setting Up Replication with Existing Data using the 'mysqldump' utility. The
-  # master has existing data.
-  #
-  desc "add_slave MASTER SLAVE", "Master has some data that is used to initialize the slave."
-  method_option :populate, :type => :boolean, :default => false
-  def add_slave(master, slave)
-    reset(slave)
-    
-    if options[:populate]
-      invoke "utils:bench", [master, "/opt/MySQL/b2.properties"]
+
+  desc "install sample config files to DIRECTORY", "After initial install, use these "
+  "as templates for configuration. The target directory must exist and be empty."
+  def install_sample_configs(dest_dir) 
+    source_dir =  File.join(Repctl::Config.const_get(:GEM_HOME), "config")
+    source_files = Dir.glob(File.join(source_dir, '*'))
+    if File.directory?(dest_dir)
+      if Dir.entries(dest_dir).size == 2 # directory is empty
+        FileUtils.copy(source_files, dest_dir)
+      else
+        say "Target directory must be empty.", :red
+      end
+    else
+      say "Config target #{to_dir} is not a directory.", :red
     end
-    file, position = invoke "mysql:dump", [master]
-    
-    # Slave is running, but it is not yet configured as a slave.
-    # Load slave from the dump file...
-    invoke "mysql:restore", [slave]
-    
-    change_master(master, slave, file, position)
-    start_slave(slave)
   end
-  
 end
 
-Mysql.start
+RepctlCmds.start

data/config/config.rb

@@ -5,10 +5,12 @@ module Repctl
     # The location of the local MySQL installation.
     MYSQL_HOME = "/usr/local/mysql"
 
-    ROOT_PASSWORD = "har526"
+    ROOT_PASSWORD = "graceling"
 
     SERVER_CONFIG = File.expand_path("../servers.yml", __FILE__)
 
+    GEM_HOME = File.expand_path("../..", __FILE__)
+
     # Define the directory where subdirectores for data will be created
     # for each MySQL server instance.  This should agree with the 
     # per server'data_dir' property in the servers.yml file, and it should

data/lib/repctl/mysql_admin.rb

@@ -68,6 +68,26 @@ module Repctl
     include Repctl::Config
     include Servers
         
+    #
+    # Public methods are:
+    #
+    #   do_secure_accounts
+    #   do_start
+    #   do_admin
+    #   do_config
+    #   do_crash
+    #   do_change_master
+    #   do_dump
+    #   do_restore
+    #   do_repl_user
+    #   do_cluster_user
+    #   do_create_widgets
+    #   get_coordinates
+    #   get_mysqld_pid
+    #   get_slave_status
+    #   run_mysql_query
+    #
+
     def do_secure_accounts(instance)
       client = Client.open(instance, :no_password => true)
       q1 = "UPDATE mysql.user SET Password = PASSWORD(\'#{ROOT_PASSWORD}\') where User = \'root\'"
@@ -147,12 +167,6 @@ module Repctl
      %x( cd #{MYSQL_HOME} && #{cmd} )
     end
 
-    def do_status(instance)
-      
-      status = get_coordinates(instance)
-      puts status
-    end
-
     #
     # Treat the instance as a slave and
     # process the output of "SHOW SLAVE STATUS".
@@ -198,39 +212,6 @@ module Repctl
       end
     end
        
-    def is_master?(instance)
-      get_slave_coordinates(instance).empty?
-    end
-
-    def is_slave?(instance)
-      !is_master?(instance)
-    end
-    
-    # This is an example template to create commands to issue queries.
-     def do_slave_status(instance)
-       client = Client.open(instance)
-       if client
-         results = client.query("SHOW SLAVE STATUS")
-         results.each_with_index do |index, line|
-           puts "#{index}: #{line}"
-         end
-       else
-         puts "Could not open connection to MySQL instance #{instance}."
-       end
-     rescue Mysql2::Error => e
-       puts e.message
-     ensure
-       client.close if client
-     end
-
-    def find_masters()
-      masters = []
-      all_servers.each do |s|
-        masters << s if is_master?(s)
-      end
-      masters
-    end
-
     #
     # From http://dev.mysql.com/doc/refman/5.0/en/lock-tables.html:
     #  
@@ -282,7 +263,6 @@ EOT
       ensure
         slave_connection.close if slave_connection
       end
-      
     end
         
     def do_dump(instance, dumpfile)
@@ -312,38 +292,6 @@ EOT
       run_cmd(cmd, true)
     end
           
-    #
-    # Get the status of replication for the master and all slaves.
-    # Return an array of hashes, each hash has the form:
-    # {:instance => <instance id>, :error => <errrmsg>, 
-    #  :master_file => <binlog-file-name>, :master_position => <binlog-position>,
-    #  :slave_file => <binlog-file-name>, :slave_position => <binlog-position>}
-    #
-    def do_slave_status(instance)
-      instance ||= DEFAULT_MASTER
-      locked = false
-      client = Client.open(instance, :timeout => 5)
-      if client
-        client.query("FLUSH TABLES WITH READ LOCK")
-        locked = true
-        results = client.query("SHOW SLAVE STATUS")
-        if results.first
-          results.first.merge("Instance" => instance, "Error" => "Success")
-        else
-          {"Instance" => instance, "Error" => "MySQL server is not a slave."}
-        end
-      else
-        {"Instance" => instance, "Error" => "Could not connect to MySQL server."}
-      end
-    rescue Mysql2::Error => e
-      {:instance => instance, "Error" => e.message}
-    ensure
-      if client
-        client.query("UNLOCK TABLES") if locked
-        client.close
-      end
-    end
-    
     # Get the master coordinates from a MySQL instance. Optionally,
     # run a block while holding the READ LOCK.
     def get_coordinates(instance)
@@ -375,30 +323,6 @@ EOT
       # coordinates
     end
 
-    def get_slave_coordinates(instance)
-      client = Client.open(instance)
-      if client
-        results = client.query("SHOW SLAVE STATUS")
-        row = results.first
-        if row
-          {:file => row["Master_Log_File"], :position => row["Read_Master_Log_Pos"]}
-        else
-          {}
-        end
-      end
-    ensure
-      client.close if client
-    end
-
-    def stop_slave_io_thread(instance)
-      client = Client.open(instance)
-      if client 
-        client.query("STOP SLAVE IO_THREAD")
-      end
-    ensure
-      client.close if client
-    end
-
     def run_mysql_query(instance, cmd)
       client = Client.open(instance)
       if client 
@@ -414,92 +338,6 @@ EOT
       client.close if client
     end
 
-    def start_slave_io_thread(instance)
-      client = Client.open(instance)
-      if client 
-        client.query("START SLAVE IO_THREAD")
-      end
-    ensure
-      client.close if client
-    end
-
-    def promote_slave_to_master(instance)
-      client = Client.open(instance)
-      if client 
-        client.query("STOP SLAVE")
-        client.query("RESET MASTER")
-      end
-    ensure
-      client.close if client
-    end
-
-    def drain_relay_log(instance)
-      done = false
-      stop_slave_io_thread(instance)
-      client = Client.open(instance)
-      if client
-        
-        # If the slave 'sql_thread' is not running, this will loop forever.
-        while !done
-          results = client.query("SHOW PROCESSLIST")
-          results.each do |row| 
-            if  row["State"] =~ /Slave has read all relay log/
-              done = true
-              puts "Slave has read all relay log."
-              break
-            end
-          end
-          puts "Waiting for slave to read relay log." unless done
-        end  
-      else
-        puts "Could not open connection to instance #{instance}."
-      end
-    ensure
-      client.close if client
-    end
-
-    # 'master' is the new master
-    # 'slaves' is contains the list of slaves, one of these may be the current master.
-    def switch_master_to(master, slaves)
-
-      slaves = Array(slaves)
-      
-      # Step 1. Make sure all slaves have completely processed their
-      # Relay Log.
-      slaves.each do |s|
-        puts "Draining relay log for slave instance #{s}"
-        drain_relay_log(s) if is_slave?(s)
-      end
-      
-      # Step 2. For the slave being promoted to master, issue STOP SLAVE
-      # and RESET MASTER.
-      client = Client.open(master)
-      client.query("STOP SLAVE")
-      client.query("RESET MASTER")
-      client.close
-
-      # Step 3.  Change the master for the other slaves (and the former master?)
-      # XXX this is not complete -- what about the coordinates?
-      master_server = server_for_instance(master)
-      master_host = 'localhost' # should be master_server[:hostname]
-      master_user = 'repl'
-      master_password = 'har526'
-      master_port = master_server[:port]
-      slaves.each do |s|
-        client = Client.open(s)
-        cmd = <<-EOT
-          CHANGE MASTER TO
-            MASTER_HOST=\'#{master_host}\',
-            MASTER_PORT=#{master_port},
-            MASTER_USER=\'#{master_user}\',
-            MASTER_PASSWORD=\'#{master_password}\'
-        EOT
-        client.query(cmd)
-        client.query("START SLAVE")
-        client.close
-      end
-    end
-    
     def do_repl_user(instance)
       hostname = "127.0.0.1"
       client = Client.open(instance)
@@ -526,7 +364,6 @@ EOT
       client.close if client
     end
     
-    
     def do_cluster_user(instance)
       client = Client.open(instance)
      
@@ -571,6 +408,16 @@ EOT
        client.close if client
      end
      
+    # Return the process ID (pid) for an instance. 
+    def get_mysqld_pid(instance)
+      server = server_for_instance(instance)
+      pidfile = server['pid-file']
+      return nil unless File.exist?(pidfile)
+      Integer(File.open(pidfile, &:readline).strip)
+    end
+
+    private
+    
      # This is an example template to create commands to issue queries.
      def template(instance)
        client = Client.open(instance)
@@ -586,8 +433,64 @@ EOT
        client.close if client
      end
 
-    private
+    # 'master' is the new master
+    # 'slaves' is contains the list of slaves, one of these may be the current master.
+    def switch_master_to(master, slaves)
+
+      slaves = Array(slaves)
+      
+      # Step 1. Make sure all slaves have completely processed their
+      # Relay Log.
+      slaves.each do |s|
+        puts "Draining relay log for slave instance #{s}"
+        drain_relay_log(s) if is_slave?(s)
+      end
+      
+      # Step 2. For the slave being promoted to master, issue STOP SLAVE
+      # and RESET MASTER.
+      client = Client.open(master)
+      client.query("STOP SLAVE")
+      client.query("RESET MASTER")
+      client.close
+
+      # Step 3.  Change the master for the other slaves (and the former master?)
+      # XXX this is not complete -- what about the coordinates?
+      master_server = server_for_instance(master)
+      master_host = 'localhost' # should be master_server[:hostname]
+      master_user = 'repl'
+      master_password = 'har526'
+      master_port = master_server[:port]
+      slaves.each do |s|
+        client = Client.open(s)
+        cmd = <<-EOT
+          CHANGE MASTER TO
+            MASTER_HOST=\'#{master_host}\',
+            MASTER_PORT=#{master_port},
+            MASTER_USER=\'#{master_user}\',
+            MASTER_PASSWORD=\'#{master_password}\'
+        EOT
+        client.query(cmd)
+        client.query("START SLAVE")
+        client.close
+      end
+    end
     
+    def is_master?(instance)
+      get_slave_coordinates(instance).empty?
+    end
+
+    def is_slave?(instance)
+      !is_master?(instance)
+    end
+    
+    def find_masters()
+      masters = []
+      all_servers.each do |s|
+        masters << s if is_master?(s)
+      end
+      masters
+    end
+
     def run_cmd(cmd, verbose)
       puts cmd if verbose
       cmd += " > /dev/null 2>&1" unless verbose
@@ -600,14 +503,129 @@ EOT
         "FAIL: exit code is #{exit_code}"
       end
     end
-       
-    # Return the process ID (pid) for an instance. 
-    def get_mysqld_pid(instance)
-      server = server_for_instance(instance)
-      pidfile = server['pid-file']
-      return nil unless File.exist?(pidfile)
-      Integer(File.open(pidfile, &:readline).strip)
+
+    def stop_slave_io_thread(instance)
+      client = Client.open(instance)
+      if client 
+        client.query("STOP SLAVE IO_THREAD")
+      end
+    ensure
+      client.close if client
+    end
+
+    # unused
+    def promote_slave_to_master(instance)
+      client = Client.open(instance)
+      if client 
+        client.query("STOP SLAVE")
+        client.query("RESET MASTER")
+      end
+    ensure
+      client.close if client
+    end
+
+    def get_slave_coordinates(instance)
+      client = Client.open(instance)
+      if client
+        results = client.query("SHOW SLAVE STATUS")
+        row = results.first
+        if row
+          {:file => row["Master_Log_File"], :position => row["Read_Master_Log_Pos"]}
+        else
+          {}
+        end
+      end
+    ensure
+      client.close if client
+    end
+
+    # unused
+    def start_slave_io_thread(instance)
+      client = Client.open(instance)
+      if client 
+        client.query("START SLAVE IO_THREAD")
+      end
+    ensure
+      client.close if client
     end
+
+    def drain_relay_log(instance)
+      done = false
+      stop_slave_io_thread(instance)
+      client = Client.open(instance)
+      if client
+        
+        # If the slave 'sql_thread' is not running, this will loop forever.
+        while !done
+          results = client.query("SHOW PROCESSLIST")
+          results.each do |row| 
+            if  row["State"] =~ /Slave has read all relay log/
+              done = true
+              puts "Slave has read all relay log."
+              break
+            end
+          end
+          puts "Waiting for slave to read relay log." unless done
+        end  
+      else
+        puts "Could not open connection to instance #{instance}."
+      end
+    ensure
+      client.close if client
+    end
+
+=begin
+    # This is an example template to create commands to issue queries.
+    def do_slave_status(instance)
+      client = Client.open(instance)
+      if client
+        results = client.query("SHOW SLAVE STATUS")
+        results.each_with_index do |index, line|
+          puts "#{index}: #{line}"
+        end
+      else
+        puts "Could not open connection to MySQL instance #{instance}."
+      end
+    rescue Mysql2::Error => e
+      puts e.message
+    ensure
+      client.close if client
+    end
+=end
+    #
+    # Get the status of replication for the master and all slaves.
+    # Return an array of hashes, each hash has the form:
+    # {:instance => <instance id>, :error => <errrmsg>, 
+    #  :master_file => <binlog-file-name>, :master_position => <binlog-position>,
+    #  :slave_file => <binlog-file-name>, :slave_position => <binlog-position>}
+    #
+    def do_slave_status(instance)
+      instance ||= DEFAULT_MASTER
+      locked = false
+      client = Client.open(instance, :timeout => 5)
+      if client
+        client.query("FLUSH TABLES WITH READ LOCK")
+        locked = true
+        results = client.query("SHOW SLAVE STATUS")
+        if results.first
+          results.first.merge("Instance" => instance, "Error" => "Success")
+        else
+          {"Instance" => instance, "Error" => "MySQL server is not a slave."}
+        end
+      else
+        {"Instance" => instance, "Error" => "Could not connect to MySQL server."}
+      end
+    rescue Mysql2::Error => e
+      {:instance => instance, "Error" => e.message}
+    ensure
+      if client
+        client.query("UNLOCK TABLES") if locked
+        client.close
+      end
+    end
+
+
+    
   end
 end
 

data/lib/repctl/version.rb

@@ -1,3 +1,3 @@
 module Repctl
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/repctl.rb

@@ -1,4 +1,8 @@
-require File.expand_path('../../config/config', __FILE__)
+# The compiled-in default is not generally very useful.
+config_dir = ENV["REPCTL_CONFIG_DIR"] ||
+  File.expand_path('../../config', __FILE__)
+  
+require File.join(config_dir, 'config')
 
 require "repctl/version"
 require "repctl/servers"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: repctl
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-01-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &205152340 !ruby/object:Gem::Requirement
+  requirement: &55282760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *205152340
+  version_requirements: *55282760
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &205150660 !ruby/object:Gem::Requirement
+  requirement: &55282340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *205150660
+  version_requirements: *55282340
 - !ruby/object:Gem::Dependency
   name: mysql2
-  requirement: &205149240 !ruby/object:Gem::Requirement
+  requirement: &55281920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *205149240
+  version_requirements: *55281920
 description: Ruby gem with Thor script to manage MySQL and PostgreSQL replication
 email:
 - lydianblues@gmail.com