global_uid 1.0.0

data/README.md

@@ -0,0 +1,130 @@
+# Global UID Plugin
+
+## Summary
+
+This plugin does a lot of the heavy lifting needed to have an external MySQL based global id generator as described in this article from Flickr
+
+(http://code.flickr.com/blog/2010/02/08/ticket-servers-distributed-unique-primary-keys-on-the-cheap/)
+
+There are three parts to it: configuration, migration and object creation
+
+### Interactions with other databases
+
+This plugin shouldn't fail with Databases other than MySQL but neither will it do anything either. There's theoretically nothing that should stop it from being *ported* to other DBs, we just don't need to.
+
+## Installation
+
+Shove this in your Gemfile and smoke it
+
+    gem "global_uid", :git => "git://github.com/zendesk/global_uid.git"
+
+### Configuration
+
+First configure some databases in database.yml in the normal way.
+
+    id_server_1:
+      adapter: mysql
+      host: id_server_db1.prod
+      port: 3306
+
+    id_server_2:
+        adapter: mysql
+        host: id_server_db2.prod
+        port: 3306
+
+Then setup these servers, and other defaults in your environment.rb:
+
+    GlobalUid.default_options = {
+      :id_servers => [ 'id_server_1', 'id_server_2' ],
+      :increment_by => 3
+    }
+
+Here's a complete list of the options you can use:
+
+    Name                  Default
+    :disabled             false                         
+            Disable GlobalUid entirely
+
+    :dry_run              false                         
+            Setting this parameter causes the REPLACE INTO statements to run, but the id picked up will not be used.
+
+    :connection_timeout   3 seconds                    
+            Timeout for connecting to a global UID server
+
+    :query_timeout        10 seconds                    
+            Timeout for retrieving a global UID from a server before we move on to the next server
+
+    :connection_retry     10.minutes
+            After failing to connect or query a UID server, how long before we retry
+
+    :use_server_variables false
+            If set, this gem will call "set @@auto_increment_offset" in order to setup the global uid servers.
+            good for test/development, not so much for production.
+    :notifier             A proc calling ActiveRecord::Base.logger
+            This proc is called with two parameters upon UID server failure -- an exception and a message
+
+    :increment_by         5
+            Chooses the step size for the increment.  This will define the maximum number of UID servers you can have.
+
+### Testing
+
+    mysqladmin -uroot create global_uid_test
+    mysqladmin -uroot create global_uid_test_id_server_1
+    mysqladmin -uroot create global_uid_test_id_server_2
+
+Copy test/config/database.yml.example to test/config/database.yml and make the modifications you need to point it to 2 local MySQL databases. Then +rake test+
+
+### Migration
+
+Migrations will now add global_uid tables for you by default.  They will also change
+your primary keys from signature "PRIMARY KEY AUTO_INCREMENT NOT NULL" to "PRIMARY KEY NOT NULL".
+
+If you'd like to disable this behavior, you can write:
+
+    class CreateFoos < ActiveRecord::Migration
+      def self.up
+        create_table :foos, :use_global_uid => false do |t|
+
+
+## Model-level stuff
+
+If you want GlobalUIDs created, you don't have to do anything except set up the GlobalUID tables
+with your migration.  Everything will be taken care you.  It's calm, and soothing like aloe.
+It's the Rails way.
+
+
+### Disabling global uid per table
+
+    class Foo < ActiveRecord::Base
+      disable_global_uid
+    end
+
+
+## Taking matters into your own hands:
+
+
+	class Foo < ActiveRecord::Base
+		disable_global_uid
+
+		def before_create
+		  self.id = generate_uid()
+		  # other stuff
+		  ....
+		end
+
+	end
+
+If you're using a non standard uid table then pass that in.
+
+    generate_uid(:uid_table => '<name>')
+
+## Submitting Bug reports, patches or improvements
+
+I welcome your feedback, bug reports, patches and improvements. Please e-mail these
+to
+    simon at zendesk.com
+    
+
+with [mysqlbigint global uid] in the subject line. I'll get back to you as soon as I can.
+
+Copyright (c) 2010 Zendesk, released under the MIT license

data/lib/global_uid/active_record_extension.rb

@@ -0,0 +1,54 @@
+module GlobalUid
+  module ActiveRecordExtension
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_inheritable_accessor :global_uid_disabled
+      base.before_create :global_uid_before_create
+    end
+
+    def global_uid_before_create
+      return if GlobalUid::Base.global_uid_options[:disabled]
+      return if self.class.global_uid_disabled
+
+      global_uid = nil
+      realtime = Benchmark::realtime do
+        global_uid = self.class.generate_uid
+      end
+      if GlobalUid::Base.global_uid_options[:dry_run]
+        ActiveRecord::Base.logger.info("GlobalUid dry-run: #{self.class.name}\t#{global_uid}\t#{"%.4f" % realtime}")
+        return
+      end
+
+      # Morten, Josh, and Ben have discussed this particular line of code, whether "||=" or "=" is correct.
+      # "||=" allows for more flexibility and more correct behavior (crashing) upon EBCAK
+      self.id ||= global_uid
+    end
+
+    module ClassMethods
+      def generate_uid(options = {})
+        uid_table_name  = self.global_uid_table
+
+        self.ensure_global_uid_table
+
+        GlobalUid::Base.get_uid_for_class(self, options)
+      end
+
+      def disable_global_uid
+        self.global_uid_disabled = true
+      end
+
+      def global_uid_table
+        GlobalUid::Base.id_table_from_name(self.table_name)
+      end
+
+      def ensure_global_uid_table
+        return @global_uid_table_exists if @global_uid_table_exists
+        GlobalUid::Base.with_connections do |connection|
+          raise "Global UID table #{global_uid_table} not found!" unless connection.table_exists?(global_uid_table)
+        end
+        @global_uid_table_exists = true
+      end
+    end
+  end
+end

data/lib/global_uid/base.rb

@@ -0,0 +1,209 @@
+require "active_record"
+require "system_timer" if Gem.available?("system_timer")
+require "timeout"
+
+module GlobalUid
+  class Base
+    @@servers = nil
+
+    GLOBAL_UID_DEFAULTS = {
+      :connection_timeout   => 3,
+      :connection_retry     => 10.minutes,
+      :notifier             => Proc.new { |exception, message| ActiveRecord::Base.logger.error("GlobalUID error:  #{exception} #{message}") },
+      :query_timeout        => 10,
+      :increment_by         => 5,  # This will define the maximum number of servers that you can have
+      :disabled             => false,
+      :per_process_affinity => true,
+      :dry_run              => false
+    }
+
+    def self.create_uid_tables(id_table_name, options={})
+      type     = options[:uid_type] || "bigint(21) UNSIGNED"
+      start_id = options[:start_id] || 1
+
+      # TODO it would be nice to be able to set the engine or something to not be MySQL specific
+      with_connections do |connection|
+        connection.execute("CREATE TABLE IF NOT EXISTS `#{id_table_name}` (
+        `id` #{type} NOT NULL AUTO_INCREMENT,
+        `stub` char(1) NOT NULL DEFAULT '',
+        PRIMARY KEY (`id`),
+        UNIQUE KEY `stub` (`stub`)
+        )")
+
+        # prime the pump on each server
+        connection.execute("INSERT IGNORE INTO `#{id_table_name}` VALUES(#{start_id}, 'a')")
+      end
+    end
+
+    def self.drop_uid_tables(id_table_name, options={})
+      with_connections do |connection|
+        connection.execute("DROP TABLE IF EXISTS `#{id_table_name}`")
+      end
+    end
+
+    if const_defined?("SystemTimer")
+      GlobalUidTimer = SystemTimer
+    else
+      GlobalUidTimer = Timeout
+    end
+
+    def self.connection_method
+      @@connection_method ||= begin
+        if ActiveRecord::Base.respond_to?(:mysql2_connection)
+          :mysql2_connection
+        elsif ActiveRecord::Base.respond_to?(:mysql_connection)
+          :mysql_connection
+        else
+          raise "No Mysql Connection Adapter found..."
+        end
+      end
+    end
+
+
+    def self.new_connection(name, connection_timeout, offset, increment_by, use_server_variables)
+      raise "No id server '#{name}' configured in database.yml" unless ActiveRecord::Base.configurations.has_key?(name)
+      config = ActiveRecord::Base.configurations[name]
+
+      con = nil
+      begin
+        GlobalUidTimer.timeout(connection_timeout, ConnectionTimeoutException) do
+          con = ActiveRecord::Base.send(self.connection_method, config)
+        end
+      rescue ConnectionTimeoutException => e
+        notify e, "Timed out establishing a connection to #{name}"
+        return nil
+      rescue Exception => e
+        notify e, "establishing a connection to #{name}: #{e.message}"
+        return nil
+      end
+
+      # Please note that this is unreliable -- if you lose your CX to the server
+      # and auto-reconnect, you will be utterly hosed.  Much better to dedicate a server
+      # or two to the cause, and set their auto_increment_increment globally.
+      if use_server_variables
+        con.execute("set @@auto_increment_increment = #{increment_by}")
+        con.execute("set @@auto_increment_offset = #{offset}")
+      end
+
+      con
+    end
+
+    def self.init_server_info(options)
+      id_servers = self.global_uid_servers
+
+      raise "You haven't configured any id servers" if id_servers.nil? or id_servers.empty?
+      raise "More servers configured than increment_by: #{id_servers.size} > #{options[:increment_by]} -- this will create duplicate IDs." if id_servers.size > options[:increment_by]
+
+      offset = 1
+
+      id_servers.map do |name, i|
+        info = {}
+        info[:cx]       = nil
+        info[:name]     = name
+        info[:retry_at] = nil
+        info[:offset]   = offset
+        info[:rand]     = rand
+        info[:new?]     = true
+        offset +=1
+        info
+      end
+    end
+
+    def self.setup_connections!(options)
+      connection_timeout = options[:connection_timeout]
+      increment_by       = options[:increment_by]
+
+      if @@servers.nil?
+        @@servers = init_server_info(options)
+        # sorting here sets up each process to have affinity to a particular server.
+        @@servers = @@servers.sort_by { |s| s[:rand] }
+      end
+
+      @@servers.each do |info|
+        next if info[:cx]
+
+        if info[:new?] || ( info[:retry_at] && Time.now > info[:retry_at] )
+          info[:new?] = false
+
+          connection = new_connection(info[:name], connection_timeout, info[:offset], increment_by, options[:use_server_variables])
+          info[:cx]  = connection
+          info[:retry_at] = Time.now + options[:connection_retry] if connection.nil?
+        end
+      end
+
+      @@servers
+    end
+
+    def self.with_connections(options = {})
+      options = self.global_uid_options.merge(options)
+      servers = setup_connections!(options)
+
+      if !options[:per_process_affinity]
+        servers = servers.sort_by { rand } #yes, I know it's not true random.
+      end
+
+      raise NoServersAvailableException if servers.empty?
+
+      exception_count = 0
+
+      errors = []
+      servers.each do |s|
+        begin
+          yield s[:cx] if s[:cx]
+        rescue TimeoutException, Exception => e
+          notify e, "#{e.message}"
+          errors << e
+          s[:cx] = nil
+          s[:retry_at] = Time.now + 10.minutes
+        end
+      end
+
+      if errors.size == servers.size
+        # The INCREDIBLY BAD CASE WHERE EVERYONE IS ERRORING!
+        # Might as well start drinking if we hit this spot in the code.
+        # note that at this point we're trying to retry on the next request.
+        servers.each { |s| s[:retry_at] = Time.now - 5.minutes }
+        raise NoServersAvailableException, "Errors hit: #{errors.map(&:to_s).join(',')}"
+      end
+
+      servers.map { |s| s[:cx] }.compact
+    end
+
+    def self.notify(exception, message)
+      if self.global_uid_options[:notifier]
+        self.global_uid_options[:notifier].call(exception, message)
+      end
+    end
+
+    def self.get_connections(options = {})
+      with_connections {}
+    end
+
+    def self.get_uid_for_class(klass, options = {})
+      with_connections do |connection|
+        timeout = self.global_uid_options[:query_timeout]
+        GlobalUidTimer.timeout(self.global_uid_options[:query_timeout], TimeoutException) do
+          id = connection.insert("REPLACE INTO #{klass.global_uid_table} (stub) VALUES ('a')")
+          return id
+        end
+      end
+      raise NoServersAvailableException, "All global UID servers are gone!"
+    end
+
+    def self.global_uid_options=(options)
+      @global_uid_options = GLOBAL_UID_DEFAULTS.merge(options.symbolize_keys)
+    end
+
+    def self.global_uid_options
+      @global_uid_options
+    end
+
+    def self.global_uid_servers
+      self.global_uid_options[:id_servers]
+    end
+
+    def self.id_table_from_name(name)
+      "#{name}_ids".to_sym
+    end
+  end
+end

data/lib/global_uid/migration_extension.rb

@@ -0,0 +1,43 @@
+module GlobalUid
+  module MigrationExtension
+    def self.included(base)
+      base.alias_method_chain :create_table, :global_uid
+      base.alias_method_chain :drop_table, :global_uid
+    end
+
+    def create_table_with_global_uid(name, options = {}, &blk)
+      uid_enabled = !(GlobalUid::Base.global_uid_options[:disabled] || options[:use_global_uid] == false)
+
+      # rules for stripping out auto_increment -- enabled, not dry-run, and not a "PK-less" table
+      remove_auto_increment = uid_enabled && !GlobalUid::Base.global_uid_options[:dry_run] && !(options[:id] == false)
+
+      if remove_auto_increment
+        old_id_option = options[:id]
+        options.merge!(:id => false)
+      end
+
+      if uid_enabled
+        id_table_name = options[:global_uid_table] || GlobalUid::Base.id_table_from_name(name)
+        GlobalUid::Base.create_uid_tables(id_table_name, options)
+      end
+
+      create_table_without_global_uid(name, options) { |t|
+        if remove_auto_increment
+          # need to honor specifically named tables
+          id_column_name = (old_id_option || :id)
+          t.column id_column_name, "int(10) NOT NULL PRIMARY KEY"
+        end
+        blk.call(t) if blk
+      }
+    end
+
+    def drop_table_with_global_uid(name, options = {})
+      if !GlobalUid::Base.global_uid_options[:disabled] && options[:use_global_uid] != false
+        id_table_name = options[:global_uid_table] || GlobalUid::Base.id_table_from_name(name)
+        GlobalUid::Base.drop_uid_tables(id_table_name,options)
+      end
+      return drop_table_without_global_uid(name,options)
+    end
+
+  end
+end

data/lib/global_uid.rb

@@ -0,0 +1,13 @@
+require "global_uid/base"
+require "global_uid/active_record_extension"
+require "global_uid/migration_extension"
+
+module GlobalUid
+  class NoServersAvailableException < Exception ; end
+  class ConnectionTimeoutException < Exception ; end
+  class TimeoutException < Exception ; end
+end
+
+ActiveRecord::Base.send(:include, GlobalUid::ActiveRecordExtension)
+ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, GlobalUid::MigrationExtension)
+

data/test/config/database.yml.example

@@ -0,0 +1,20 @@
+test:
+  adapter: mysql2
+  encoding: utf8
+  database: global_uid_test
+  username: root
+  password:
+
+test_id_server_1:
+  adapter: mysql2
+  encoding: utf8
+  database: global_uid_test_id_server_1
+  username: root
+  password:
+
+test_id_server_2:
+  adapter: mysql2
+  encoding: utf8
+  database: global_uid_test_id_server_2
+  username: root
+  password:

data/test/global_uid_test.rb

@@ -0,0 +1,362 @@
+require 'test_helper'
+
+class CreateWithNoParams < ActiveRecord::Migration
+  group :change if self.respond_to?(:group)
+
+  def self.up
+    create_table :with_global_uids do |t|
+      t.string  :description
+    end
+  end
+
+  def self.down
+    drop_table :with_global_uids
+  end
+end
+
+class CreateWithNamedID < ActiveRecord::Migration
+  group :change if self.respond_to?(:group)
+
+  def self.up
+    create_table :with_global_uids, :id => 'hello' do |t|
+      t.string  :description
+    end
+  end
+
+  def self.down
+    drop_table :with_global_uids
+  end
+end
+
+class CreateWithoutGlobalUIDs < ActiveRecord::Migration
+  group :change if self.respond_to?(:group)
+
+  def self.up
+    create_table :without_global_uids, :use_global_uid => false do |t|
+      t.string  :description
+    end
+  end
+
+  def self.down
+    drop_table :without_global_uids, :use_global_uid => false
+  end
+end
+
+class WithGlobalUID < ActiveRecord::Base
+end
+
+class WithoutGlobalUID < ActiveRecord::Base
+end
+
+class GlobalUIDTest < ActiveSupport::TestCase
+  ActiveRecord::Migration.verbose = false
+
+  context "migrations" do
+    setup do
+      restore_defaults!
+      reset_connections!
+      drop_old_test_tables!
+    end
+
+    context "without explicit parameters" do
+      context "with global-uid enabled" do
+        setup do
+          GlobalUid::Base.global_uid_options[:disabled] = false
+          CreateWithNoParams.up
+          @create_table = show_create_sql(WithGlobalUID, "with_global_uids").split("\n")
+        end
+
+        should "create the global_uids table" do
+          GlobalUid::Base.with_connections do |cx|
+            assert cx.table_exists?('with_global_uids_ids')
+          end
+        end
+
+        should "create global_uids tables with matching ids" do
+          GlobalUid::Base.with_connections do |cx|
+            foo = cx.select_all("select id from with_global_uids_ids")
+            assert(foo.first['id'].to_i == 1)
+          end
+        end
+
+        should "tear off the auto_increment part of the primary key from the created table" do
+          id_line = @create_table.grep(/\`id\` int/i).first
+          assert_no_match /auto_increment/i, id_line
+        end
+
+        should "create a primary key on id" do
+          assert @create_table.grep(/primary key/i).size > 0
+        end
+
+        teardown do
+          CreateWithNoParams.down
+        end
+      end
+
+      context "with global-uid disabled, globally" do
+        setup do
+          GlobalUid::Base.global_uid_options[:disabled] = true
+          CreateWithNoParams.up
+        end
+
+        should "not create the global_uids table" do
+          GlobalUid::Base.with_connections do |cx|
+            assert !cx.table_exists?('with_global_uids_ids')
+          end
+        end
+
+        teardown do
+          CreateWithNoParams.down
+          GlobalUid::Base.global_uid_options[:disabled] = false
+        end
+      end
+
+      context "with a named ID key" do
+        setup do
+          CreateWithNamedID.up
+        end
+
+        should "preserve the name of the ID key" do
+          @create_table = show_create_sql(WithGlobalUID, "with_global_uids").split("\n")
+          assert(@create_table.grep(/hello.*int/i))
+          assert(@create_table.grep(/primary key.*hello/i))
+        end
+
+        teardown do
+          CreateWithNamedID.down
+        end
+      end
+    end
+
+    context "with global-uid disabled in the migration" do
+      setup do
+        CreateWithoutGlobalUIDs.up
+        @create_table = show_create_sql(WithoutGlobalUID, "without_global_uids").split("\n")
+      end
+
+      should "not create the global_uids table" do
+        GlobalUid::Base.with_connections do |cx|
+          assert !cx.table_exists?('without_global_uids_ids')
+        end
+      end
+
+      should "create standard auto-increment tables" do
+        id_line = @create_table.grep(/.id. int/i).first
+        assert_match /auto_increment/i, id_line
+      end
+
+      teardown do
+        CreateWithoutGlobalUIDs.down
+      end
+    end
+  end
+
+  context "With GlobalUID" do
+    setup do
+      reset_connections!
+      drop_old_test_tables!
+      restore_defaults!
+      CreateWithNoParams.up
+      CreateWithoutGlobalUIDs.up
+    end
+
+    context "normally" do
+      should "get a unique id" do
+        test_unique_ids
+      end
+    end
+
+    context "With a timing out server" do
+      setup do
+        reset_connections!
+        @a_decent_cx = GlobalUid::Base.new_connection(GlobalUid::Base.global_uid_servers.first, 50, 1, 5, true)
+        ActiveRecord::Base.stubs(:mysql_connection).raises(GlobalUid::ConnectionTimeoutException).then.returns(@a_decent_cx)
+        @connections = GlobalUid::Base.get_connections
+      end
+
+      should "limp along with one functioning server" do
+        assert @connections.include?(@a_decent_cx)
+        assert_equal GlobalUid::Base.global_uid_servers.size - 1,  @connections.size, "get_connections size"
+      end
+
+      should "eventually retry the connection and get it back in place" do
+        # clear the state machine expectation
+        ActiveRecord::Base.mysql_connection rescue nil
+        ActiveRecord::Base.mysql_connection rescue nil
+
+        awhile = Time.now + 10.hours
+        Time.stubs(:now).returns(awhile)
+
+        assert GlobalUid::Base.get_connections.size == GlobalUid::Base.global_uid_servers.size
+
+      end
+
+      should "get some unique ids" do
+        test_unique_ids
+      end
+    end
+
+    context "With a server timing out on query" do
+      setup do
+        reset_connections!
+        @old_size = GlobalUid::Base.get_connections.size # prime them
+        GlobalUid::Base.get_connections.first.stubs(:execute).raises(GlobalUid::TimeoutException)
+        # trigger the failure -- have to do it it a bunch of times, as one call might not hit the server
+        # Even so there's a 1/(2^32) possibility of this test failing.
+        32.times do WithGlobalUID.create! end
+      end
+
+      should "pull the server out of the pool" do
+        assert GlobalUid::Base.get_connections.size == @old_size - 1
+      end
+
+      should "get ids from the remaining server" do
+        test_unique_ids
+      end
+
+      should "eventually retry the connection" do
+        awhile = Time.now + 10.hours
+        Time.stubs(:now).returns(awhile)
+
+        assert GlobalUid::Base.get_connections.size == GlobalUid::Base.global_uid_servers.size
+      end
+    end
+
+    context "With both servers throwing exceptions" do
+      setup do
+        # would prefer to do the below, but need Mocha 0.9.10 to do so
+        # ActiveRecord::ConnectionAdapters::MysqlAdapter.any_instance.stubs(:execute).raises(ActiveRecord::StatementInvalid)
+        GlobalUid::Base.with_connections do |cx|
+          cx.stubs(:execute).raises(ActiveRecord::StatementInvalid)
+        end
+      end
+
+      should "raise a NoServersAvailableException" do
+        assert_raises(GlobalUid::NoServersAvailableException) do
+          WithGlobalUID.create!
+        end
+      end
+
+      should "retry the servers immediately after failure" do
+        assert_raises(GlobalUid::NoServersAvailableException) do
+          WithGlobalUID.create!
+        end
+
+        assert WithGlobalUID.create!
+      end
+    end
+
+
+    context "with per-process_affinity" do
+      setup do
+        GlobalUid::Base.global_uid_options[:per_process_affinity] = true
+      end
+
+      should "increment sequentially" do
+        last_id = 0
+        10.times do
+          this_id = WithGlobalUID.create!.id
+          assert this_id > last_id
+        end
+      end
+
+      teardown do
+        GlobalUid::Base.global_uid_options[:per_process_affinity] = false
+      end
+    end
+
+    context "with global-uid disabled" do
+      setup do
+        WithoutGlobalUID.disable_global_uid
+      end
+
+      should "never call various unsafe methods" do
+        GlobalUid::Base.expects(:new_connection).never
+        GlobalUid::Base.expects(:get_uid_for_class).never
+        WithoutGlobalUID.expects(:generate_uid).never
+        WithoutGlobalUID.expects(:ensure_global_uid).never
+        GlobalUid::Base.expects(:get_uid_for_class).never
+      end
+
+      teardown do
+      end
+    end
+
+    teardown do
+      mocha_teardown # tear down mocha early to prevent some of this being tied to mocha expectations
+      reset_connections!
+      CreateWithNoParams.down
+      CreateWithoutGlobalUIDs.down
+    end
+  end
+
+  context "In dry-run mode" do
+    setup do
+      reset_connections!
+      drop_old_test_tables!
+      GlobalUid::Base.global_uid_options[:dry_run] = true
+      CreateWithNoParams.up
+    end
+
+    should "create a normal looking table" do
+
+    end
+
+    should "increment normally1" do
+      (1..10).each do |i|
+        assert_equal i, WithGlobalUID.create!.id
+      end
+    end
+
+    should "insert into the UID servers nonetheless" do
+      GlobalUid::Base.expects(:get_uid_for_class).at_least(10)
+      10.times { WithGlobalUID.create! }
+    end
+
+    should "log the results" do
+      ActiveRecord::Base.logger.expects(:info).at_least(10)
+      10.times { WithGlobalUID.create! }
+    end
+
+    teardown do
+      reset_connections!
+      CreateWithNoParams.down
+      GlobalUid::Base.global_uid_options[:dry_run] = false
+    end
+  end
+
+  private
+  def test_unique_ids
+    seen = {}
+    (0..10).each do
+      foo = WithGlobalUID.new
+      foo.save
+      assert !foo.id.nil?
+      assert foo.description.nil?
+      assert !seen.has_key?(foo.id)
+      seen[foo.id] = 1
+    end
+  end
+
+  def drop_old_test_tables!
+    GlobalUid::Base.with_connections do |cx|
+      cx.execute("DROP TABLE IF exists with_global_uids_ids")
+    end
+  end
+
+  def reset_connections!
+    GlobalUid::Base.class_eval "@@servers = nil"
+  end
+
+  def restore_defaults!
+    GlobalUid::Base.global_uid_options[:disabled] = false
+    GlobalUid::Base.global_uid_options[:use_server_variables] = true
+    GlobalUid::Base.global_uid_options[:dry_run] = false
+  end
+
+  def show_create_sql(klass, table)
+    klass.connection.select_all("show create table #{table}")[0]["Create Table"]
+  end
+end
+
+

data/test/test_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+
+require 'bundler'
+Bundler.setup
+
+require "active_record"
+require "active_support"
+require "active_support/test_case"
+require "shoulda"
+require "global_uid"
+
+GlobalUid::Base.global_uid_options = {
+  :use_server_variables => true,
+  :disabled   => false,
+  :id_servers => [
+    "test_id_server_1",
+    "test_id_server_2"
+  ]
+}
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + "/config/database.yml"))
+ActiveRecord::Base.establish_connection("test")
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/test.log")

metadata

@@ -0,0 +1,295 @@
+--- !ruby/object:Gem::Specification 
+name: global_uid
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Ben Osheroff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: global_uid
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :runtime
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id006
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirements: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 3
+        - 10
+        version: 2.3.10
+  prerelease: false
+  type: :runtime
+  requirement: *id007
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirements: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 3
+        - 10
+        version: 2.3.10
+  prerelease: false
+  type: :runtime
+  requirement: *id008
+- !ruby/object:Gem::Dependency 
+  name: SystemTimer
+  version_requirements: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 2
+        version: "1.2"
+  prerelease: false
+  type: :runtime
+  requirement: *id009
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  version_requirements: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 45
+        segments: 
+        - 2
+        - 8
+        - 1
+        version: 2.8.1
+  prerelease: false
+  type: :runtime
+  requirement: *id010
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirements: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id011
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  version_requirements: &id012 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id012
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  version_requirements: &id013 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id013
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  version_requirements: &id014 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id014
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  version_requirements: &id015 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  requirement: *id015
+description: Zendesk GUID
+email: 
+- ben@zendesk.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/global_uid.rb
+- lib/global_uid/active_record_extension.rb
+- lib/global_uid/base.rb
+- lib/global_uid/migration_extension.rb
+- README.md
+- test/config/database.yml.example
+- test/global_uid_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/zendesk/global_uid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Zendesk GUID
+test_files: 
+- test/config/database.yml.example
+- test/global_uid_test.rb
+- test/test_helper.rb