mysql_manager 1.0.0

data/README.md

@@ -0,0 +1,75 @@
+# MySQL Manager
+
+MySQL Manager is a utility to perform routine tasks on a MySQL database. 
+
+  * Continuously execute `SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1` and `START SLAVE` statements until replication is caught up (leaves slave in inconsistent state with master) 
+  * Reload `my.cnf` without restarting MySQL (limited to dynamic variables)
+  * Kill queries that match a set of criteria (execution time, user, db, state, command, host, query) using PCRE regexes or literal strings. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mysql_manager'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mysql_manager
+
+## Usage
+
+    Usage: mysql-manager options
+            --kill                       Kill queries based on specified criteria
+            --kill:max-query-time TIME   Kill queries that have been running for more than TIME
+            --kill:user USER             Kill queries matching USER (repeatable)
+            --kill:host HOST             Kill queries matching HOST (repeatable)
+            --kill:query SQL             Kill queries matching SQL (repeatable)
+            --kill:command COMMAND       Kill queries matching COMMAND (repeatable)
+            --kill:state STATE           Kill queries matching STATE (repeatable)
+            --kill:db DB                 Kill queries matching DB (repeatable)
+            --skip-replication-errors    Skip replication errors based on specified criteria
+            --skip-replication-errors:max-error-duration SECONDS
+                                         Abort after attempting to recover after SECONDS elapsed (default: )
+            --skip-replication-errors:min-healthy-duration SECONDS
+                                         Abort after replication healthy for SECONDS elapsed (default: -1)
+            --skip-replication-errors:max-errors SECONDS
+                                         Output replication status events every SECONDS elapsed (default: 10)
+            --reload-my-cnf              Reload my.cnf based on specified criteria
+            --reload-my-cnf:config FILE  Issue set 'SET GLOBAL' for each variable in FILE (default: /etc/my.cnf)
+            --reload-my-cnf:groups GROUP Issue set 'SET GLOBAL' for each variable in FILE (default: mysqld, mysqld_safe, mysql.server, mysql_server, server, mysql)
+            --db:dsn DSN                 DSN to connect to MySQL database (default: DBI:Mysql:mysql:localhost)
+            --db:username USERNAME       Username corresponding to DSN (default: root)
+            --db:password PASSWORD       Password corresponding to DSN (default: )
+            --log:level LEVEL            Logging level
+            --log:file FILE              Write logs to FILE (default: STDERR)
+            --log:age DAYS               Rotate logs after DAYS pass (default: 7)
+            --log:size SIZE              Rotate logs after the grow past SIZE bytes
+            --dry-run                    Do not run statements which affect the state of the database when executed
+        -V, --version                    Display version information
+        -h, --help                       Display this screen
+
+## Examples
+
+Kill all queries by user "api" that have been running longer than 30 seconds:
+
+    mysql-manager --kill --kill:user api --kill:max-query-time 30 --log:level DEBUG --dry-run
+
+Recover a MySQL Slave that has failed replication and wait for it to remain healthy (fully caught up to master) for 60 seconds.
+
+    mysql-manager --skip-replication-errors --skip-replication-errors:min-healthy-duration 60 --log:level DEBUG
+
+Reload `/etc/my.cnf` without restarting MySQL:
+
+    mysql-manager --reload-my-cnf --reload-my-cnf:config /etc/my.cnf --log:level DEBUG
+    
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/mysql-manager

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+#
+# MySQL Manager - a utility to perform routine tasks on a MySQL database
+# Copyright (C) 2012 Erik Osterman <e@osterman.com>
+# 
+# This file is part of MySQL Manager.
+# 
+# MySQL Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# MySQL Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with MySQL Manager.  If not, see <http://www.gnu.org/licenses/>.
+#
+$:.unshift(File.expand_path('.')) # Ruby 1.9 doesn't have . in the load path...
+$:.push(File.expand_path('lib/')) 
+
+require 'rubygems'
+require 'mysql_manager'
+
+command_line = MysqlManager::CommandLine.new
+command_line.execute

data/lib/mysql_manager.rb

@@ -0,0 +1,25 @@
+#
+# MySQL Manager - a utility to perform routine tasks on a MySQL database
+# Copyright (C) 2012 Erik Osterman <e@osterman.com>
+# 
+# This file is part of MySQL Manager.
+# 
+# MySQL Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# MySQL Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with MySQL Manager.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'mysql_manager/version'
+require 'mysql_manager/utilities'
+require 'mysql_manager/command_line'
+
+module MysqlManager
+end

data/lib/mysql_manager/command_line.rb

@@ -0,0 +1,245 @@
+#
+# MySQL Manager - a utility to perform routine tasks on a MySQL database
+# Copyright (C) 2012 Erik Osterman <e@osterman.com>
+# 
+# This file is part of MySQL Manager.
+# 
+# MySQL Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# MySQL Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with MySQL Manager.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'optparse'
+
+module MysqlManager
+  class MissingArgumentException < Exception; end
+
+  class CommandLine
+    attr_accessor :utilities
+
+    def to_pattern(str)
+      if str =~ /^\/(.*?)\/$/
+        Regexp.new($1.to_s)
+      else
+        Regexp.new("^#{Regexp.escape(str)}$")
+      end
+    end
+
+    def initialize
+      @options = {}
+      @options[:db] = {}
+      @options[:log] = {}
+      @options[:kill] = {}
+      @options[:reload_my_cnf] = {}
+      @options[:skip_replication_errors] = {}
+
+      begin
+        @optparse = OptionParser.new do |opts|
+          opts.banner = "Usage: #{$0} options"
+          
+        
+          #
+          # Killing options
+          #
+          @options[:kill][:execute] = false
+          opts.on( '--kill', 'Kill queries based on specified criteria') do
+            @options[:kill][:execute] = true
+          end
+
+          @options[:kill][:max_query_time] = -1
+          opts.on( '--kill:max-query-time TIME', 'Kill queries that have been running for more than TIME') do |time|
+            @options[:kill][:max_query_time] = time.to_i
+          end
+
+          @options[:kill][:user] = []
+          opts.on( '--kill:user USER', 'Kill queries matching USER (repeatable)') do |user|
+            @options[:kill][:user] << to_pattern(user) 
+          end
+
+          @options[:kill][:host] = []
+          opts.on( '--kill:host HOST', 'Kill queries matching HOST (repeatable)') do |host|
+            @options[:kill][:host] << to_pattern(host) 
+          end
+
+          @options[:kill][:query] = []
+          opts.on( '--kill:query SQL', 'Kill queries matching SQL (repeatable)') do |sql|
+            @options[:kill][:query] << to_pattern(sql) 
+          end
+
+          @options[:kill][:command] = []
+          opts.on( '--kill:command COMMAND', 'Kill queries matching COMMAND (repeatable)') do |command|
+            @options[:kill][:command] << to_pattern(command) 
+          end
+
+          @options[:kill][:state] = []
+          opts.on( '--kill:state STATE', 'Kill queries matching STATE (repeatable)') do |state|
+            @options[:kill][:state] << to_patterns(state) 
+          end
+
+          @options[:kill][:db] = []
+          opts.on( '--kill:db DB', 'Kill queries matching DB (repeatable)') do |db|
+            @options[:kill][:db] << to_pattern(db) 
+          end
+
+          #
+          # Skip Replication Error options
+          #
+          @options[:skip_replication_errors][:execute] = false
+          opts.on( '--skip-replication-errors', 'Skip replication errors based on specified criteria') do
+            @options[:skip_replication_errors][:execute] = true
+          end
+
+          @options[:skip_replication_errors][:max_errors] = -1
+          opts.on( '--skip-replication-errors:max-errors NUMBER', "Abort after encountering NUMBER of errors (default: #{@options[:skip_replication_errors][:max_errors]})") do |number|
+            @options[:skip_replication_errors][:max_errors] = number.to_i
+          end
+
+          @options[:skip_replication_errors][:max_error_duration] = -1
+          opts.on( '--skip-replication-errors:max-error-duration SECONDS', "Abort after attempting to recover after SECONDS elapsed (default: #{@options[:skip_replication_errors][:max_error_durration]})") do |seconds|
+            @options[:skip_replication_errors][:max_error_duration] = seconds.to_i
+          end
+
+          @options[:skip_replication_errors][:min_healthy_duration] = -1
+          opts.on( '--skip-replication-errors:min-healthy-duration SECONDS', "Abort after replication healthy for SECONDS elapsed (default: #{@options[:skip_replication_errors][:min_healthy_duration]})") do |seconds|
+            @options[:skip_replication_errors][:min_healthy_duration] = seconds.to_i
+          end
+
+          @options[:skip_replication_errors][:log_frequency] = 10
+          opts.on( '--skip-replication-errors:max-errors SECONDS', "Output replication status events every SECONDS elapsed (default: #{@options[:skip_replication_errors][:log_frequency]})") do |seconds|
+            @options[:skip_replication_errors][:log_frequency] = seconds.to_i
+          end
+ 
+          #
+          # Reload my.cnf options
+          #
+          @options[:reload_my_cnf][:execute] = false
+          opts.on( '--reload-my-cnf', 'Reload my.cnf based on specified criteria') do
+            @options[:reload_my_cnf][:execute] = true
+          end
+
+
+          @options[:reload_my_cnf][:config] = '/etc/my.cnf'
+          opts.on( '--reload-my-cnf:config FILE', "Issue set 'SET GLOBAL' for each variable in FILE (default: #{@options[:reload_my_cnf][:config]})") do |file|
+            @options[:reload_my_cnf][:config] = file
+          end
+
+          @options[:reload_my_cnf][:groups] = ['mysqld', 'mysqld_safe', 'mysql.server', 'mysql_server', 'server', 'mysql']
+          opts.on( '--reload-my-cnf:groups GROUP', "Issue set 'SET GLOBAL' for each variable in FILE (default: #{@options[:reload_my_cnf][:groups].join(', ')})") do |group|
+            @options[:reload_my_cnf][:groups] << group
+          end
+
+
+          #
+          # Database connection options
+          #
+          @options[:db][:dsn] = 'DBI:Mysql:mysql:localhost'
+          opts.on( '--db:dsn DSN', "DSN to connect to MySQL database (default: #{@options[:db][:dsn]})" ) do|dsn|
+            @options[:db][:dsn] = dsn
+          end
+
+          @options[:db][:username] = 'root'
+          opts.on( '--db:username USERNAME', "Username corresponding to DSN (default: #{@options[:db][:username]})" ) do|username|
+            @options[:username] = username
+          end
+
+          @options[:db][:password] = ""
+          opts.on( '--db:password PASSWORD', "Password corresponding to DSN (default: #{@options[:db][:password]})" ) do|password|
+            @options[:db][:password] = password
+          end
+
+          #
+          # Logging options
+          #
+          @options[:log][:level] = Logger::INFO
+          opts.on( '--log:level LEVEL', 'Logging level' ) do|level|
+            @options[:log][:level] = Logger.const_get level.upcase
+          end
+
+          @options[:log][:file] = STDERR
+          opts.on( '--log:file FILE', 'Write logs to FILE (default: STDERR)' ) do|file|
+            @options[:log][:file] = File.open(file, File::WRONLY | File::APPEND | File::CREAT)
+          end
+
+          @options[:log][:age] = 7
+          opts.on( '--log:age DAYS', "Rotate logs after DAYS pass (default: #{@options[:log][:age]})" ) do|days|
+            @options[:log][:age] = days.to_i
+          end
+
+          @options[:log][:size] = 1024*1024*10
+          opts.on( '--log:size SIZE', 'Rotate logs after the grow past SIZE bytes' ) do |size|
+            @options[:log][:size] = size.to_i
+          end
+
+          # 
+          # General options
+          #
+          @options[:dry_run] = false
+          opts.on( '--dry-run', 'Do not run statements which affect the state of the database when executed' ) do
+            @options[:dry_run] = true
+          end
+
+
+          opts.on( '-V', '--version', 'Display version information' ) do
+            puts "MySQL Manager #{MysqlManager::VERSION}"
+            puts "Copyright (C) 2012 Erik Osterman <e@osterman.com>"
+            puts "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>"
+            puts "This is free software: you are free to change and redistribute it."
+            puts "There is NO WARRANTY, to the extent permitted by law."
+            exit
+          end
+
+          opts.on( '-h', '--help', 'Display this screen' ) do
+            puts opts
+            exit
+          end
+        end
+
+        @optparse.parse!
+
+        raise MissingArgumentException.new("No action specified") if @options.select { |k,v| v.instance_of?(Hash) && v.has_key?(:execute) && v[:execute] == true }.size == 0
+        @log = Logger.new(@options[:log][:file], @options[:log][:age], @options[:log][:size])
+        @log.level = @options[:log][:level]
+        @utilities = Utilities.new(@options[:db])
+        @utilities.log = @log
+        @utilities.dry_run = @options[:dry_run]
+      rescue MissingArgumentException => e
+        puts e.message
+        puts @optparse
+        exit (1)
+      end
+    end
+
+    def execute
+      @options.each do |type,options|
+        next if options.instance_of?(Hash) && options.has_key?(:execute) && options[:execute] == false
+        begin
+          case type
+          when :kill
+            @log.debug("about to call kill_queries")
+            @utilities.kill_queries(options)
+          when :skip_replication_errors
+            @log.debug("about to call skip_replication_errors")
+            @utilities.skip_replication_errors(options)
+          when :reload_my_cnf
+            @log.debug("about to call reload_my_cnf")
+            @utilities.reload_my_cnf(options)
+          end
+        rescue FileNotFoundException => e
+          @log.fatal(e.message)
+        rescue Interupt
+          @log.info("Exiting")
+        rescue Exception => e
+          @log.fatal(e.message + e.backtrace.join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/mysql_manager/utilities.rb

@@ -0,0 +1,215 @@
+#
+# MySQL Manager - a utility to perform routine tasks on a MySQL database
+# Copyright (C) 2012 Erik Osterman <e@osterman.com>
+# 
+# This file is part of MySQL Manager.
+# 
+# MySQL Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# MySQL Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with MySQL Manager.  If not, see <http://www.gnu.org/licenses/>.
+#
+require 'dbi'
+require 'logger'
+require 'parseconfig'
+
+module MysqlManager
+  class FileNotFoundException < Exception; end
+
+  class Utilities
+    attr_accessor :dbh, :log, :dry_run
+
+    def initialize(options = {})
+      options[:dsn] ||= "DBI:Mysql:mysql:localhost"
+      options[:username] ||= "root"
+      options[:password] ||= ""
+
+      @log = Logger.new(STDERR)
+
+      # connect to the MySQL server
+      @dbh = DBI.connect(options[:dsn], options[:username], options[:password])
+    end
+
+    def kill_queries(options = {})
+      options[:max_query_time] ||= -1
+      options[:user] ||= []
+      options[:host] ||= []
+      options[:query] ||= []
+      options[:command] ||= []
+      options[:state] ||= []
+      options[:db] ||= []
+      
+      @dbh.execute("SHOW FULL PROCESSLIST") do |sth|
+        sth.fetch_hash() do |row| 
+          next if row['Command'] == 'Binlog Dump'
+          next if row['User'] == 'system user'
+
+          results = []
+          options.each_pair do |field,criteria|
+            case field
+            when :max_query_time
+              if criteria >= 0
+                if row['Time'].to_i > criteria
+                  results << true
+                else
+                  results << false
+                end
+              end
+            when :user, :host, :query, :command, :state, :db
+              if criteria.length > 0
+                matched = false
+                criteria.each do |pattern|
+                  if pattern.match(row[field.to_s.capitalize])
+                    matched = true
+                    break
+                  end
+                end
+                #puts "#{row[field.to_s.capitalize]} #{criteria.inspect} == #{matched}"
+                results << matched
+              end
+            end
+          end
+          # Some conditions need to apply
+          #puts results.inspect
+          if results.length > 0
+            # None of them may be false
+            unless results.include?(false)
+              begin
+                @log.info("Killing id:#{row['Id']} db:#{row['db']} user:#{row['User']} command:#{row['Command']} state:#{row['State']} time:#{row['Time']} host:#{row['Host']} query:#{row['Info']} rows_sent:#{row['Rows_sent']} rows_examined:#{row['Rows_examined']} rows_read:#{row['Rows_read']}")
+                @dbh.do("KILL #{row['Id']}") unless @dry_run
+              rescue DBI::DatabaseError => e
+                @log.warn(e.message)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def reload_my_cnf(options = {})
+      options[:config] ||= '/etc/my.cnf'
+      options[:groups] ||= ['mysqld', 'mysqld_safe', 'mysql.server', 'mysql_server', 'server', 'mysql']
+
+      variables = {}
+      @dbh.execute("SHOW VARIABLES") do |sth|
+        sth.fetch_hash() do |row| 
+          variables[row['Variable_name']] = row['Value']
+        end
+      end
+      unless File.exists?(options[:config])
+        raise FileNotFoundException.new("Unable to open file #{options[:config]}")
+      end
+      
+      my_cnf = ParseConfig.new(options[:config])
+      my_cnf.groups.each do |group|
+      if options[:groups].include?(group)
+          @log.debug("loading values from [#{group}]")
+          my_cnf[group].each_pair do |k,v|
+            next if v.nil? || v.empty?
+            if variables.has_key?(k)
+              begin
+                v = v.to_s
+                v = v.to_i if v =~ /^(\d+)$/
+                v = $1.to_i * (1024) if v =~ /^(\d+)K$/
+                v = $1.to_i * (1024*1024) if v =~ /^(\d+)M$/
+                v = $1.to_i * (1024*1024*1024) if v =~ /^(\d+)G$/
+                if v.instance_of?(Integer) || v.instance_of?(Fixnum)
+                  sql = "SET GLOBAL #{k} = #{v}"
+                else
+                  sql = "SET GLOBAL #{k} = '#{v}'"
+                end
+                @dbh.do(sql) unless @dry_run
+                @log.info("set #{k}=#{v}")
+              rescue DBI::DatabaseError => e
+                @log.debug(@dbh.last_statement)
+                @log.warn(e.message)
+              end
+            end
+          end
+        end 
+      end
+    end
+
+    def skip_replication_errors(options = {})
+      options[:max_errors] ||= -1
+      options[:max_error_duration] ||= -1
+      options[:min_healthy_duration] ||= -1
+      options[:log_frequency] ||= 10
+
+      begin
+        # get server version string and display it
+        max_seconds_behind = 0
+        t_start = Time.now.to_f
+        t_last_error = nil
+        t_last_error_elapsed = 0
+        t_last_log = 0
+        t_elapsed = 0
+        t_recovered = 0
+        errors = 0
+        while (options[:max_errors] < 0 || errors < options[:max_errors]) && (options[:max_error_duration] < 0 || t_last_error_elapsed < options[:max_error_duration])
+          @dbh.execute("SHOW SLAVE STATUS") do |sth|
+            t_now = Time.now.to_f
+      
+            sth.fetch_hash() do |row| 
+              seconds_behind = row['Seconds_Behind_Master']
+              if seconds_behind.nil?
+                @log.info("replication broken")
+                @log.info("last error: #{row['Last_Error'].gsub(/\r?\n/, '')}")
+
+                @dbh.do("SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1") unless @dry_run
+                @dbh.do("START SLAVE")
+                errors += 1
+                max_seconds_behind = 0
+                t_last_error = t_now
+              elsif seconds_behind == 0
+                t_recovered = t_now if t_recovered == 0
+                if t_last_log == 0 || t_now - t_last_log > options[:log_frequency]
+                  @log.info("fully caught up with master")
+                  t_last_log = t_now
+                end
+                if (t_min_healthy_duration >=0) && (t_now - t_recovered > t_min_healthy_duration)
+                  @log.info("satisfied health duration window")
+                  break
+                end
+              else
+                seconds_behind = seconds_behind.to_f
+                t_recovered = 0
+                t_last_error_elapsed = t_last_error.nil? ? 0 : t_now - t_last_error
+                t_elapsed = t_now - t_start
+                max_seconds_behind = [max_seconds_behind, seconds_behind].max
+                t_catchup = max_seconds_behind - seconds_behind
+                t_rate = t_elapsed == 0 ? 1 : t_catchup/t_elapsed
+                t_left = t_rate > 0 ? seconds_behind/t_rate : 0
+                if t_left > 60*60
+                  t_left_str = sprintf('%.2f hours', t_left/(60*60))
+                elsif t_left > 60
+                  t_left_str = sprintf('%.2f mins', t_left/60)
+                else
+                  t_left_str = sprintf('%.2f secs', t_left)
+                end
+                if t_last_log == 0 || t_now.to_f - t_last_log.to_f > options[:log_frequency]
+                  @log.info("#{seconds_behind} seconds behind master; #{t_catchup} seconds caught up; #{sprintf('%.2f', t_rate)} seconds/second; #{t_left_str} left; #{errors} errors; last error #{sprintf('%.2f', t_last_error_elapsed)} seconds ago")
+                  t_last_log = t_now
+                end
+
+                sleep 0.100
+              end
+            end
+          end
+        end
+      rescue Interrupt
+        @log.info("Aborted by user")
+      rescue DBI::DatabaseError => e
+        @log.error("Error code: #{e.err}: #{e.errstr}")
+      end
+    end
+  end
+end