maatkit-ruby 0.1.0

data/lib/maatkit-ruby/mk-checksum-filter.rb

@@ -0,0 +1,122 @@
+  # = maatkit-ruby - A maatkit gem for Ruby
+  #
+  # Homepage::  http://github.com/jjuliano/maatkit-ruby
+  # Author::    Joel Bryan Juliano
+  # Copyright:: (cc) 2011 Joel Bryan Juliano
+  # License::   MIT
+
+  #
+  # Filter checksums from mk-table-checksum.
+  #
+  # Maatkit::ChecksumFilter.new( array, str, array)
+  #
+  class Maatkit::ChecksumFilter
+
+    #
+    # type: Hash
+    # This comma-separated list of databases are equal.
+    # These database names are always considered to have the same tables. In other words, this makes database1.table1.chunk1 equal to database2.table1.chunk1 if they have the same checksum.
+    # This disables incremental processing, so you won't see any results until all input is processed.
+    attr_accessor :equal_databases
+
+    #
+    # short form: -h
+    # Preserves headers output by mk-table-checksum.
+    attr_accessor :header # FALSE
+
+    #
+    # Show help and exit.
+    attr_accessor :help # TRUE
+
+    #
+    # Ignore the database name when comparing lines.
+    # This disables incremental processing, so you won't see any results until all input is processed.
+    attr_accessor :ignore_databases # FALSE
+
+    #
+    # type: string
+    # The name of the master server.
+    # Specifies which host is the replication master, and sorts lines for that host first, so you can see the checksum values on the master server before the slave.
+    attr_accessor :master
+
+    #
+    # type: string
+    # Show unique differing host/db/table names.
+    # The argument must be one of host, db, or table.
+    attr_accessor :unique # (No value)
+
+    #
+    # short form: -v
+    # Output all lines, even those that have no differences, except for header lines.
+    attr_accessor :verbose # FALSE
+
+    #
+    # Show version and exit.
+    attr_accessor :version # FALSE
+
+    #
+    # Sets the executable path, otherwise the environment path will be used.
+    #
+    attr_accessor :path_to_mk_checksum_filter
+
+    #
+    # Returns a new ChecksumFilter Object
+    #
+    def initialize()
+    end
+
+    #
+    # Execute the command
+    #
+    def start(options = nil)
+      tmp = Tempfile.new('tmp')
+      command = option_string() + options.to_s + " 2> " + tmp.path
+      success = system(command)
+      if success
+        begin
+          while (line = tmp.readline)
+            line.chomp
+            selected_string = line
+          end
+        rescue EOFError
+          tmp.close
+        end
+        return selected_string
+      else
+        tmp.close!
+        return success
+      end
+    end
+
+    def config
+      option_string()
+    end
+
+    private
+
+    def option_string()
+
+      unless @path_to_mk_checksum_filter
+        ostring = "mk-checksum-filter "
+      else
+        ostring = @path_to_mk_checksum_filter + " "
+      end
+
+      self.instance_variables.each do |i|
+        tmp_value = self.instance_variable_get "#{i}"
+        tmp_string = i.gsub("_", "-").gsub("@", "--")
+        unless tmp_string == "--path-to-mk-checksum-filter"
+          if (tmp_value.is_a? TrueClass) || (tmp_value.is_a? FalseClass)
+            ostring += "#{tmp_string} "
+          else
+            ostring += "#{tmp_string} #{tmp_value} "
+          end
+        end
+      end
+
+      return ostring
+
+    end
+
+  end
+

data/lib/maatkit-ruby/mk-deadlock-logger.rb

@@ -0,0 +1,223 @@
+  # = maatkit-ruby - A maatkit gem for Ruby
+  #
+  # Homepage::  http://github.com/jjuliano/maatkit-ruby
+  # Author::    Joel Bryan Juliano
+  # Copyright:: (cc) 2011 Joel Bryan Juliano
+  # License::   MIT
+
+  #
+  # Extract and log MySQL deadlock information.
+  #
+  # Maatkit::DeadlockLogger.new( array, str, array)
+  #
+  class Maatkit::DeadlockLogger
+
+    #
+    # Prompt for a password when connecting to MySQL.
+    attr_accessor :ask_pass # FALSE
+
+    #
+    # short form: -A; type: string
+    # Default character set. If the value is utf8, sets Perl's binmode on STDOUT to utf8, passes the mysql_enable_utf8 option to DBD::mysql, and runs SET NAMES UTF8 after connecting to MySQL. Any other value sets binmode on STDOUT without the utf8 layer, and runs SET NAMES after connecting to MySQL.
+    attr_accessor :charset # (No value)
+
+    #
+    # type: string
+    # Use this table to create a small deadlock. This usually has the effect of clearing out a huge deadlock, which otherwise consumes the entire output of SHOW INNODB STATUS. The table must not exist. mk-deadlock-logger will create it with the following MAGIC_clear_deadlocks structure:
+    #   CREATE TABLE test.deadlock_maker(a INT PRIMARY KEY) ENGINE=InnoDB;
+    # After creating the table and causing a small deadlock, the tool will drop the table again.
+    attr_accessor :clear_deadlocks # (No value)
+
+    #
+    # Collapse whitespace in queries to a single space. This might make it easier to inspect on the command line or in a query. By default, whitespace is collapsed when printing with --print, but not modified when storing to --dest. (That is, the default is different for each action).
+    attr_accessor :collapse # FALSE
+
+    #
+    # type: hash
+    # Output only this comma-separated list of columns. See OUTPUT for more details on columns.
+    attr_accessor :columns # (No value)
+
+    #
+    # type: Array
+    # Read this comma-separated list of config files; if specified, this must be the first option on the command line.
+    attr_accessor :config # /etc/maatkit/maatkit.conf,/etc/maatkit/mk_deadlock_logger.conf,/home/joel/.maatkit.conf,/home/joel/.mk_deadlock_logger.conf
+
+    #
+    # Create the table specified by --dest.
+    # Normally the --dest table is expected to exist already. This option causes mk-deadlock-logger to create the table automatically using the suggested table structure.
+    attr_accessor :create_dest_table # FALSE
+
+    #
+    # Fork to the background and detach from the shell. POSIX operating systems only.
+    attr_accessor :daemonize # FALSE
+
+    #
+    # short form: -F; type: string
+    # Only read mysql options from the given file. You must give an absolute pathname.
+    attr_accessor :defaults_file # (No value)
+
+    #
+    # type: DSN
+    # DSN for where to store deadlocks; specify at least a database (D) and table (t).
+    # Missing values are filled in with the same values from the source host, so you can usually omit most parts of this argument if you're storing deadlocks on the same server on which they happen.
+    # By default, whitespace in the query column is left intact; use --[no]collapse if you want whitespace collapsed.
+    # The following MAGIC_dest_table is suggested if you want to store all the information mk-deadlock-logger can extract about deadlocks:
+    #  CREATE TABLE deadlocks (
+    #    server char(20) NOT NULL,
+    #    ts datetime NOT NULL,
+    #    thread int unsigned NOT NULL,
+    #    txn_id bigint unsigned NOT NULL,
+    #    txn_time smallint unsigned NOT NULL,
+    #    user char(16) NOT NULL,
+    #    hostname char(20) NOT NULL,
+    #    ip char(15) NOT NULL, -- alternatively, ip int unsigned NOT NULL
+    #    db char(64) NOT NULL,
+    #    tbl char(64) NOT NULL,
+    #    idx char(64) NOT NULL,
+    #    lock_type char(16) NOT NULL,
+    #    lock_mode char(1) NOT NULL,
+    #    wait_hold char(1) NOT NULL,
+    #    victim tinyint unsigned NOT NULL,
+    #    query text NOT NULL,
+    #    PRIMARY KEY  (server,ts,thread)
+    #  ) ENGINE=InnoDB
+    # If you use --columns, you can omit whichever columns you don't want to store.
+    attr_accessor :dest # (No value)
+
+    #
+    # Show help and exit.
+    attr_accessor :help # TRUE
+
+    #
+    # short form: -h; type: string
+    # Connect to host.
+    attr_accessor :host # (No value)
+
+    #
+    # type: time
+    # How often to check for deadlocks. If no --run-time is specified, mk-deadlock-logger runs forever, checking for deadlocks at every interval. See also --run-time.
+    attr_accessor :interval # (No value)
+
+    #
+    # type: string
+    # Print all output to this file when daemonized.
+    attr_accessor :log # (No value)
+
+    #
+    # Express IP addresses as integers.
+    attr_accessor :numeric_ip # FALSE
+
+    #
+    # short form: -p; type: string
+    # Password to use when connecting.
+    attr_accessor :password # (No value)
+
+    #
+    # type: string
+    # Create the given PID file when daemonized. The file contains the process ID of the daemonized instance. The PID file is removed when the daemonized instance exits. The program checks for the existence of the PID file when starting; if it exists and the process with the matching PID exists, the program exits.
+    attr_accessor :pid # (No value)
+
+    #
+    # short form: -P; type: int
+    # Port number to use for connection.
+    attr_accessor :port # (No value)
+
+    #
+    # Print results on standard output. See OUTPUT for more. By default, enables --[no]collapse unless you explicitly disable it.
+    # If --interval or --run-time is specified, only new deadlocks are printed at each interval. A fingerprint for each deadlock is created using --columns server, ts and thread (even if those columns were not specified by --columns) and if the current deadlock's fingerprint is different from the last deadlock's fingerprint, then it is printed.
+    attr_accessor :print # FALSE
+
+    #
+    # type: time
+    # How long to run before exiting. By default mk-deadlock-logger runs once, checks for deadlocks, and exits. If --run-time is specified but no --interval is specified, a default 1 second interval will be used.
+    attr_accessor :run_time # (No value)
+
+    #
+    # type: string; default: wait_timeout=10000
+    # Set these MySQL variables. Immediately after connecting to MySQL, this string will be appended to SET and executed.
+    attr_accessor :set_vars # wait_timeout=10000
+
+    #
+    # short form: -S; type: string
+    # Socket file to use for connection.
+    attr_accessor :socket # (No value)
+
+    #
+    # Print tab-separated columns, instead of aligned.
+    attr_accessor :tab # FALSE
+
+    #
+    # short form: -u; type: string
+    # User for login if not current user.
+    attr_accessor :user # (No value)
+
+    #
+    # Show version and exit.
+    attr_accessor :version # FALSE
+
+    #
+    # Sets the executable path, otherwise the environment path will be used.
+    #
+    attr_accessor :path_to_mk_deadlock_logger
+
+    #
+    # Returns a new DeadlockLogger Object
+    #
+    def initialize()
+    end
+
+    #
+    # Execute the command
+    #
+    def start(options = nil)
+      tmp = Tempfile.new('tmp')
+      command = option_string() + options.to_s + " 2> " + tmp.path
+      success = system(command)
+      if success
+        begin
+          while (line = tmp.readline)
+            line.chomp
+            selected_string = line
+          end
+        rescue EOFError
+          tmp.close
+        end
+        return selected_string
+      else
+        tmp.close!
+        return success
+      end
+    end
+
+    def config
+      option_string()
+    end
+
+    private
+
+    def option_string()
+
+      unless @path_to_mk_deadlock_logger
+        ostring = "mk-deadlock-logger "
+      else
+        ostring = @path_to_mk_deadlock_logger + " "
+      end
+
+      self.instance_variables.each do |i|
+        tmp_value = self.instance_variable_get "#{i}"
+        tmp_string = i.gsub("_", "-").gsub("@", "--")
+        unless tmp_string == "--path-to-mk-deadlock-logger"
+          if (tmp_value.is_a? TrueClass) || (tmp_value.is_a? FalseClass)
+            ostring += "#{tmp_string} "
+          else
+            ostring += "#{tmp_string} #{tmp_value} "
+          end
+        end
+      end
+
+      return ostring
+
+    end
+
+  end
+

data/lib/maatkit-ruby/mk-duplicate-key-checker.rb

@@ -0,0 +1,239 @@
+  # = maatkit-ruby - A maatkit gem for Ruby
+  #
+  # Homepage::  http://github.com/jjuliano/maatkit-ruby
+  # Author::    Joel Bryan Juliano
+  # Copyright:: (cc) 2011 Joel Bryan Juliano
+  # License::   MIT
+
+  #
+  # Find duplicate indexes and foreign keys on MySQL tables.
+  #
+  # Maatkit::DuplicateKeyChecker.new( array, str, array)
+  #
+  class Maatkit::DuplicateKeyChecker
+
+    #
+    # Compare indexes with different structs (BTREE, HASH, etc).
+    # By default this is disabled, because a BTREE index that covers the same columns as a FULLTEXT index is
+    # not really a duplicate, for example.
+    attr_accessor :all_structs # FALSE
+
+    #
+    # Prompt for a password when connecting to MySQL.
+    attr_accessor :ask_pass # FALSE
+
+    #
+    # short form: -A; type: string
+    # Default character set.  If the value is utf8, sets Perl's binmode on STDOUT to utf8, passes the
+    # mysql_enable_utf8 option to DBD::mysql, and runs SET NAMES UTF8 after connecting to MySQL.  Any other
+    # value sets binmode on STDOUT without the utf8 layer, and runs SET NAMES after connecting to MySQL.
+    attr_accessor :charset # (No value)
+
+    #
+    # default: yes
+    # PK columns appended to secondary key is duplicate.
+    # Detects when a suffix of a secondary key is a leftmost prefix of the primary key, and treats it as a
+    # duplicate key.  Only detects this condition on storage engines whose primary keys are clustered
+    # (currently InnoDB and solidDB).
+    # Clustered storage engines append the primary key columns to the leaf nodes of all secondary keys
+    # anyway, so you might consider it redundant to have them appear in the internal nodes as well.  Of
+    # course, you may also want them in the internal nodes, because just having them at the leaf nodes won't
+    # help for some queries.  It does help for covering index queries, however.
+    # Here's an example of a key that is considered redundant with this option:
+    #  PRIMARY KEY  (`a`)
+    #  KEY `b` (`b`,`a`)
+    # The use of such indexes is rather subtle.  For example, suppose you have the following query:
+    #  SELECT ... WHERE b=1 ORDER BY a;
+    # This query will do a filesort if we remove the index on "b,a".  But if we shorten the index on "b,a" to
+    # just "b" and also remove the ORDER BY, the query should return the same results.
+    # The tool suggests shortening duplicate clustered keys by dropping the key and re-adding it without the
+    # primary key prefix.  The shortened clustered key may still duplicate another key, but the tool cannot
+    # currently detect when this happens without being ran a second time to re-check the newly shortened
+    # clustered keys.  Therefore, if you shorten any duplicate clusterted keys, you should run the tool
+    # again.
+    attr_accessor :clustered # TRUE
+
+    #
+    # type: Array
+    # Read this comma-separated list of config files; if specified, this must be the first option on the
+    # command line.
+    attr_accessor :config # /etc/maatkit/maatkit.conf,/etc/maatkit/mk_duplicate_key_checker.conf,/home/joel/.maatkit.conf,/home/joel/.mk_duplicate_key_checker.conf
+
+    #
+    # short form: -d; type: hash
+    # Check only this comma-separated list of databases.
+    attr_accessor :databases # (No value)
+
+    #
+    # short form: -F; type: string
+    # Only read mysql options from the given file.  You must give an absolute pathname.
+    attr_accessor :defaults_file # (No value)
+
+    #
+    # short form: -e; type: hash
+    # Check only tables whose storage engine is in this comma-separated list.
+    attr_accessor :engines # (No value)
+
+    #
+    # Show help and exit.
+    attr_accessor :help # TRUE
+
+    #
+    # short form: -h; type: string
+    # Connect to host.
+    attr_accessor :host # (No value)
+
+    #
+    # type: Hash
+    # Ignore this comma-separated list of databases.
+    attr_accessor :ignore_databases #
+
+    #
+    # type: Hash
+    # Ignore this comma-separated list of storage engines.
+    attr_accessor :ignore_engines #
+
+    #
+    # Ignore index order so KEY(a,b) duplicates KEY(b,a).
+    attr_accessor :ignore_order # FALSE
+
+    #
+    # type: Hash
+    # Ignore this comma-separated list of tables.  Table names may be qualified with the database name.
+    attr_accessor :ignore_tables #
+
+    #
+    # type: string; default: fk
+    # Check for duplicate f=foreign keys, k=keys or fk=both.
+    attr_accessor :key_types # fk
+
+    #
+    # short form: -p; type: string
+    # Password to use when connecting.
+    attr_accessor :password # (No value)
+
+    #
+    # type: string
+    # Create the given PID file.  The file contains the process ID of the script.  The PID file is removed
+    # when the script exits.  Before starting, the script checks if the PID file already exists.  If it does
+    # not, then the script creates and writes its own PID to it.  If it does, then the script checks the
+    # following: if the file contains a PID and a process is running with that PID, then the script dies; or,
+    # if there is no process running with that PID, then the script overwrites the file with its own PID and
+    # starts; else, if the file contains no PID, then the script dies.
+    attr_accessor :pid # (No value)
+
+    #
+    # short form: -P; type: int
+    # Port number to use for connection.
+    attr_accessor :port # (No value)
+
+    #
+    # type: string; default: wait_timeout=10000
+    # Set these MySQL variables.  Immediately after connecting to MySQL, this string will be appended to SET
+    # and executed.
+    attr_accessor :set_vars # wait_timeout=10000
+
+    #
+    # short form: -S; type: string
+    # Socket file to use for connection.
+    attr_accessor :socket # (No value)
+
+    #
+    # default: yes
+    # Print DROP KEY statement for each duplicate key.  By default an ALTER TABLE DROP KEY statement is
+    # printed below each duplicate key so that, if you want to remove the duplicate key, you can copy-paste
+    # the statement into MySQL.
+    # To disable printing these statements, specify --nosql.
+    attr_accessor :sql # TRUE
+
+    #
+    # default: yes
+    # Print summary of indexes at end of output.
+    attr_accessor :summary # TRUE
+
+    #
+    # short form: -t; type: hash
+    # Check only this comma-separated list of tables.
+    # Table names may be qualified with the database name.
+    attr_accessor :tables # (No value)
+
+    #
+    # short form: -u; type: string
+    # User for login if not current user.
+    attr_accessor :user # (No value)
+
+    #
+    # short form: -v
+    # Output all keys and/or foreign keys found, not just redundant ones.
+    attr_accessor :verbose # FALSE
+
+    #
+    # Show version and exit.
+    attr_accessor :version # FALSE
+
+    #
+    # Sets the executable path, otherwise the environment path will be used.
+    #
+    attr_accessor :path_to_mk_duplicate_key_checker
+
+    #
+    # Returns a new DuplicateKeyChecker Object
+    #
+    def initialize()
+    end
+
+    #
+    # Execute the command
+    #
+    def start(options = nil)
+      tmp = Tempfile.new('tmp')
+      command = option_string() + options.to_s + " 2> " + tmp.path
+      success = system(command)
+      if success
+        begin
+          while (line = tmp.readline)
+            line.chomp
+            selected_string = line
+          end
+        rescue EOFError
+          tmp.close
+        end
+        return selected_string
+      else
+        tmp.close!
+        return success
+      end
+    end
+
+    def config
+      option_string()
+    end
+
+    private
+
+    def option_string()
+
+      unless @path_to_mk_duplicate_key_checker
+        ostring = "mk-duplicate-key-checker "
+      else
+        ostring = @path_to_mk_duplicate_key_checker + " "
+      end
+
+      self.instance_variables.each do |i|
+        tmp_value = self.instance_variable_get "#{i}"
+        tmp_string = i.gsub("_", "-").gsub("@", "--")
+        unless tmp_string == "--path-to-mk-duplicate-key-checker"
+          if (tmp_value.is_a? TrueClass) || (tmp_value.is_a? FalseClass)
+            ostring += "#{tmp_string} "
+          else
+            ostring += "#{tmp_string} #{tmp_value} "
+          end
+        end
+      end
+
+      return ostring
+
+    end
+
+  end
+