global_uid 3.7.1 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66c3d7277c02d403b85ba5a0c89357d1fa23d3c80817678226fc9e0ffd945e99
-  data.tar.gz: a922b9dfec3c753668e4cf5b14fbc2c795cb0d57b7d728fbbd85f5a725e18ada
+  metadata.gz: bc0bc131f043570b57245aa1b807b4f7e74dd87aefc17db5b403d2d7e615f5e5
+  data.tar.gz: a0048d1ebec4af921f0fee12db3ade0e37bfcc5af282f94e61f197fdb182ff17
 SHA512:
-  metadata.gz: f3101805f0c413c2ece2aba4cab83e890e9bc4966304074cb21fea7f12ba0ba5f9f7d6d50ae89ceae81c8178f5717f3791151c14c8f41da3aebc858f2a9a7278
-  data.tar.gz: c575ec0cd1cd707bfb7aa18e4acad03fc4423a070553dc5b1d06288f0d541084efaaca12fc60144461b45538ce0a369ba564899500604e6c58e3191130efd689
+  metadata.gz: df66f3a63d4b00c946e76f41cb18817e3790ba229be243ba1abf6cbc555cec1d778316782afdb87ac9769d47cef151b41e3a3b0f47b8640b0ccc6fb9e5f0dcbe
+  data.tar.gz: 987393d901a7d49897a4362c58a88d851695af84fdc137c307781acdc3b21dd00537608d241814d7293e4d12e3c26fe3ad96dfa085228ecbcff6d6edfb69fe1f

data/lib/global_uid.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 require "global_uid/base"
+require "global_uid/allocator"
+require "global_uid/server"
+require "global_uid/configuration"
+require "global_uid/error_tracker"
 require "global_uid/active_record_extension"
 require "global_uid/has_and_belongs_to_many_builder_extension"
 require "global_uid/migration_extension"
@@ -9,8 +13,36 @@ module GlobalUid
   class NoServersAvailableException < StandardError ; end
   class ConnectionTimeoutException < StandardError ; end
   class TimeoutException < StandardError ; end
+  class InvalidIncrementException < StandardError ; end
 
-  autoload :ServerVariables, "global_uid/server_variables"
+  def self.configuration
+    @configuration ||= GlobalUid::Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  def self.disable!
+    self.configuration.disabled = true
+  end
+
+  def self.enable!
+    self.configuration.disabled = false
+  end
+
+  def self.enabled?
+    !self.disabled?
+  end
+
+  def self.disabled?
+    self.configuration.disabled
+  end
+
+  # @private
+  def self.reset_configuration
+    @configuration = nil
+  end
 end
 
 ActiveRecord::Base.send(:include, GlobalUid::ActiveRecordExtension)
@@ -26,10 +58,5 @@ if ActiveRecord::VERSION::MAJOR >= 5
   ActiveRecord::InternalMetadata.disable_global_uid
 end
 
-if ActiveRecord::VERSION::STRING >= '4.1.0'
-  ActiveRecord::Associations::Builder::HasAndBelongsToMany.send(:include, GlobalUid::HasAndBelongsToManyBuilderExtension)
-end
-
-if ActiveRecord::VERSION::MAJOR >= 4
-  ActiveRecord::SchemaDumper.send(:prepend, GlobalUid::SchemaDumperExtension)
-end
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.send(:include, GlobalUid::HasAndBelongsToManyBuilderExtension)
+ActiveRecord::SchemaDumper.send(:prepend, GlobalUid::SchemaDumperExtension)

data/lib/global_uid/active_record_extension.rb

@@ -8,20 +8,10 @@ module GlobalUid
     end
 
     def global_uid_before_create
-      return if GlobalUid::Base.global_uid_options[:disabled]
+      return if GlobalUid.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
-
-      self.id = global_uid
+      self.id = self.class.generate_uid
     end
 
     module ClassMethods
@@ -37,12 +27,16 @@ module GlobalUid
         @global_uid_disabled
       end
 
-      def generate_uid(options = {})
-        GlobalUid::Base.get_uid_for_class(self, options)
+      def generate_uid
+        GlobalUid::Base.with_servers do |server|
+          return server.allocate(self)
+        end
       end
 
-      def generate_many_uids(count, options = {})
-        GlobalUid::Base.get_many_uids_for_class(self, count, options)
+      def generate_many_uids(count)
+        GlobalUid::Base.with_servers do |server|
+          return Array(server.allocate(self, count: count))
+        end
       end
 
       def disable_global_uid
@@ -54,7 +48,7 @@ module GlobalUid
       end
 
       def global_uid_table
-        GlobalUid::Base.id_table_from_name(self.table_name)
+        @_global_uid_table ||= GlobalUid::Base.id_table_from_name(self.table_name)
       end
     end
   end

data/lib/global_uid/allocator.rb

@@ -0,0 +1,51 @@
+module GlobalUid
+  class Allocator
+    attr_reader :recent_allocations, :max_window_size, :incrementing_by, :connection, :table_name
+
+    def initialize(incrementing_by:, connection:, table_name:)
+      @recent_allocations = []
+      @max_window_size = 5
+      @incrementing_by = incrementing_by
+      @connection = connection
+      @table_name = table_name
+    end
+
+    def allocate_one
+      identifier = connection.insert("REPLACE INTO #{table_name} (stub) VALUES ('a')")
+      allocate(identifier)
+    end
+
+    def allocate_many(count:)
+      return [] unless count > 0
+
+      increment_by = connection.select_value("SELECT @@auto_increment_increment")
+
+      start_id = connection.insert("REPLACE INTO #{table_name} (stub) VALUES " + (["('a')"] * count).join(','))
+      identifiers = start_id.step(start_id + (count - 1) * increment_by, increment_by).to_a
+      identifiers.each { |identifier| allocate(identifier) }
+      identifiers
+    end
+
+    private
+
+    def allocate(identifier)
+      recent_allocations.shift if recent_allocations.size >= max_window_size
+      recent_allocations << identifier
+
+      if !valid_allocation?
+        db_increment = connection.select_value("SELECT @@auto_increment_increment")
+        message = "Configured: '#{incrementing_by}', Found: '#{db_increment}' on '#{connection.current_database}'. Recently allocated IDs: #{recent_allocations} using table '#{table_name}'"
+        GlobalUid::Base.alert(InvalidIncrementException.new(message))
+      end
+
+      identifier
+    end
+
+    def valid_allocation?
+      recent_allocations[1..-1].all? do |identifier|
+        (identifier > recent_allocations[0]) &&
+          (identifier - recent_allocations[0]) % incrementing_by == 0
+      end
+    end
+  end
+end

data/lib/global_uid/base.rb

@@ -6,17 +6,6 @@ require "timeout"
 
 module GlobalUid
   class Base
-    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.servers
       # Thread local storage is inheritted on `fork`, include the pid
       Thread.current["global_uid_servers_#{$$}"]
@@ -26,180 +15,66 @@ module GlobalUid
       Thread.current["global_uid_servers_#{$$}"] = s
     end
 
-    def self.create_uid_tables(id_table_name, options={})
-      type     = options[:uid_type] || "bigint(21) UNSIGNED"
-      start_id = options[:start_id] || 1
-
-      engine_stmt = "ENGINE=#{global_uid_options[:storage_engine] || "MyISAM"}"
-
-      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`)
-        ) #{engine_stmt}")
-
-        # 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
-
-    def self.new_connection(name, connection_timeout, offset, increment_by)
-      raise "No id server '#{name}' configured in database.yml" unless ActiveRecord::Base.configurations.to_h.has_key?(name)
-      config = ActiveRecord::Base.configurations.to_h[name]
-      c = config.symbolize_keys
-
-      raise "No global_uid support for adapter #{c[:adapter]}" if c[:adapter] != 'mysql2'
-
-      begin
-        Timeout.timeout(connection_timeout, ConnectionTimeoutException) do
-          ActiveRecord::Base.mysql2_connection(config)
-        end
-      rescue ConnectionTimeoutException => e
-        notify e, "Timed out establishing a connection to #{name}"
-        nil
-      rescue Exception => e
-        notify e, "establishing a connection to #{name}: #{e.message}"
-        nil
-      end
-    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
+    def self.init_server_info
+      GlobalUid.configuration.id_servers.map do |name|
+        GlobalUid::Server.new(name,
+          increment_by: GlobalUid.configuration.increment_by,
+          connection_retry: GlobalUid.configuration.connection_retry,
+          connection_timeout: GlobalUid.configuration.connection_timeout,
+          query_timeout: GlobalUid.configuration.query_timeout
+        )
+      end.shuffle # so each process uses a random server
     end
 
     def self.disconnect!
+      servers.each(&:disconnect!) unless servers.nil?
       self.servers = nil
     end
 
-    def self.setup_connections!(options)
-      connection_timeout = options[:connection_timeout]
-      increment_by       = options[:increment_by]
+    def self.with_servers
+      self.servers ||= init_server_info
+      servers = self.servers.each(&:connect)
 
-      if self.servers.nil?
-        self.servers = init_server_info(options)
-        # sorting here sets up each process to have affinity to a particular server.
-        self.servers = self.servers.sort_by { |s| s[:rand] }
+      if GlobalUid.configuration.connection_shuffling?
+        servers.shuffle! # subsequent requests are made against different servers
       end
 
-      self.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)
-          info[:cx]  = connection
-          info[:retry_at] = Time.now + options[:connection_retry] if connection.nil?
-        end
-      end
-
-      self.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?
-
       errors = []
-      servers.each do |s|
+      servers.each do |server|
         begin
-          yield s[:cx] if s[:cx]
+          yield server if server.active?
         rescue TimeoutException, Exception => e
-          notify e, "#{e.message}"
+          GlobalUid.configuration.notifier.call(e)
           errors << e
-          s[:cx] = nil
-          s[:retry_at] = Time.now + 1.minute
+          server.disconnect!
+          server.update_retry_at(1.minute)
         end
       end
 
       # in the case where all servers are gone, put everyone back in.
-      if servers.all? { |info| info[:cx].nil? }
-        servers.each do |info|
-          info[:retry_at] = Time.now - 5.minutes
+      if servers.all?(&:disconnected?)
+        servers.each do |server|
+          server.update_retry_at(0)
         end
-        raise NoServersAvailableException, "Errors hit: #{errors.map(&:to_s).join(',')}"
+        message = errors.empty? ? "" : "Errors hit: #{errors.map(&:to_s).join(', ')}"
+        exception = NoServersAvailableException.new(message)
+        GlobalUid.configuration.notifier.call(exception)
+        raise exception
       end
 
-      servers.map { |s| s[:cx] }.compact
+      servers
     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.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!"
+    def self.id_table_from_name(name)
+      "#{name}_ids".to_sym
     end
 
-    def self.get_many_uids_for_class(klass, count, options = {})
-      return [] unless count > 0
-      with_connections do |connection|
-        Timeout.timeout(self.global_uid_options[:query_timeout], TimeoutException) do
-          increment_by = connection.select_value("SELECT @@auto_increment_increment")
-          start_id = connection.insert("REPLACE INTO #{klass.global_uid_table} (stub) VALUES " + (["('a')"] * count).join(','))
-          return start_id.step(start_id + (count-1) * increment_by, increment_by).to_a
-        end
+    def self.alert(exception)
+      if GlobalUid.configuration.suppress_increment_exceptions?
+        GlobalUid.configuration.notifier.call(exception)
+      else
+        raise exception
       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/configuration.rb

@@ -0,0 +1,66 @@
+module GlobalUid
+  class Configuration
+
+    attr_accessor :connection_timeout
+    attr_accessor :connection_retry
+    attr_accessor :notifier
+    attr_accessor :query_timeout
+    attr_accessor :increment_by
+    attr_accessor :disabled
+    attr_accessor :connection_shuffling
+    attr_accessor :suppress_increment_exceptions
+    attr_accessor :storage_engine
+
+    alias_method :connection_shuffling?, :connection_shuffling
+    alias_method :suppress_increment_exceptions?, :suppress_increment_exceptions
+
+    # Set defaults
+    def initialize
+      # Timeout (in seconds) for connecting to a global UID server
+      @connection_timeout = 3
+
+      # Duration (in seconds) to wait before attempting another connection to UID server
+      @connection_retry = 600 # 10 minutes
+
+      # An object that will be notified in case of a UID server failure.
+      # The object is expected to respond to `#call`, which will be passed one argument of type `Exception`.
+      @notifier = GlobalUid::ErrorTracker.new
+
+      # Timeout (in seconds) for retrieving a global UID from a server before moving to the next server
+      @query_timeout = 10
+
+      # Used for validation, compared with the value on the alloc servers to prevent allocation of duplicate IDs
+      #   NB: The value configured here does not dictate the value on your alloc server and must remain in
+      #       sync with the value of auto_increment_increment in the database.
+      @increment_by = 5
+
+      # Disable GlobalUid entirely
+      @disabled = false
+
+      # The same allocation server is used each time `with_servers` is called
+      @connection_shuffling = false
+
+      # Suppress configuration validation, allowing updates to auto_increment_increment while alloc servers in use.
+      # The InvalidIncrementException will be swallowed and logged when suppressed
+      @suppress_increment_exceptions = false
+
+      # The name of the alloc DB servers, defined in your database.yml
+      # e.g. ["id_server_1", "id_server_2"]
+      @id_servers = []
+
+      # The storage engine used during GloblaUid table creation
+      # Supported and tested: InnoDB, MyISAM
+      @storage_engine = "MyISAM"
+    end
+
+    def id_servers=(value)
+      raise "More servers configured than increment_by: #{value.size} > #{increment_by} -- this will create duplicate IDs." if value.size > increment_by
+      @id_servers = value
+    end
+
+    def id_servers
+      raise "You haven't configured any id servers" if @id_servers.empty?
+      @id_servers
+    end
+  end
+end

data/lib/global_uid/error_tracker.rb

@@ -0,0 +1,7 @@
+module GlobalUid
+  class ErrorTracker
+    def call(exception)
+      ActiveRecord::Base.logger.error("GlobalUID error: #{exception.class} #{exception.message}")
+    end
+  end
+end

data/lib/global_uid/migration_extension.rb

@@ -3,10 +3,10 @@ module GlobalUid
   module MigrationExtension
 
     def create_table(name, options = {}, &blk)
-      uid_enabled = !(GlobalUid::Base.global_uid_options[:disabled] || options[:use_global_uid] == false)
+      uid_enabled = GlobalUid.enabled? && 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)
+      # rules for stripping out auto_increment -- enabled and not a "PK-less" table
+      remove_auto_increment = uid_enabled && !(options[:id] == false)
 
       options.merge!(:id => false) if remove_auto_increment
 
@@ -17,15 +17,23 @@ module GlobalUid
 
       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)
+        GlobalUid::Base.with_servers do |server|
+          server.create_uid_table!(
+            name: id_table_name,
+            uid_type: options[:uid_type],
+            start_id: options[:start_id]
+          )
+        end
       end
 
     end
 
     def drop_table(name, options = {})
-      if !GlobalUid::Base.global_uid_options[:disabled] && options[:use_global_uid] == true
+      if GlobalUid.enabled? && options[:use_global_uid] == true
         id_table_name = options[:global_uid_table] || GlobalUid::Base.id_table_from_name(name)
-        GlobalUid::Base.drop_uid_tables(id_table_name,options)
+        GlobalUid::Base.with_servers do |server|
+          server.drop_uid_table!(name: id_table_name)
+        end
       end
       super(name, options)
     end

data/lib/global_uid/server.rb

@@ -0,0 +1,121 @@
+module GlobalUid
+  class Server
+
+    attr_accessor :connection, :name
+
+    def initialize(name, increment_by:, connection_retry:, connection_timeout:, query_timeout:)
+      @connection = nil
+      @name = name
+      @retry_at = nil
+      @allocators = {}
+      @increment_by = increment_by
+      @connection_retry = connection_retry
+      @connection_timeout = connection_timeout
+      @query_timeout = query_timeout
+    end
+
+    def connect
+      return @connection if active? || !retry_connection?
+      @connection = mysql2_connection(name)
+
+      begin
+        validate_connection_increment if active?
+      rescue InvalidIncrementException => e
+        GlobalUid.configuration.notifier.call(e)
+        disconnect!
+      end
+
+      @connection
+    end
+
+    def active?
+      !disconnected?
+    end
+
+    def disconnected?
+      @connection.nil?
+    end
+
+    def update_retry_at(seconds)
+      @retry_at = Time.now + seconds
+    end
+
+    def disconnect!
+      @connection = nil
+      @allocators = {}
+    end
+
+    def create_uid_table!(name:, uid_type: nil, start_id: nil)
+      uid_type ||= "bigint(21) UNSIGNED"
+      start_id ||= 1
+
+      connection.execute("CREATE TABLE IF NOT EXISTS `#{name}` (
+      `id` #{uid_type} NOT NULL AUTO_INCREMENT,
+      `stub` char(1) NOT NULL DEFAULT '',
+      PRIMARY KEY (`id`),
+      UNIQUE KEY `stub` (`stub`)
+      ) ENGINE=#{GlobalUid.configuration.storage_engine}")
+
+      # prime the pump on each server
+      connection.execute("INSERT IGNORE INTO `#{name}` VALUES(#{start_id}, 'a')")
+    end
+
+    def drop_uid_table!(name:)
+      connection.execute("DROP TABLE IF EXISTS `#{name}`")
+    end
+
+    def allocate(klass, count: 1)
+      # TODO: Replace Timeout.timeout with DB level timeout
+      #   Timeout.timeout is unpredictable
+      Timeout.timeout(query_timeout, TimeoutException) do
+        if count == 1
+          allocator(klass).allocate_one
+        else
+          allocator(klass).allocate_many(count: count)
+        end
+      end
+    end
+
+    private
+
+    attr_accessor :connection_retry, :connection_timeout, :retry_at, :increment_by, :query_timeout, :allocators
+
+    def allocator(klass)
+      table_name = klass.global_uid_table
+      @allocators[table_name] ||= Allocator.new(incrementing_by: increment_by, connection: connection, table_name: table_name)
+    end
+
+    def retry_connection?
+      return Time.now > retry_at if retry_at
+
+      update_retry_at(connection_retry)
+      true
+    end
+
+    def mysql2_connection(name)
+      raise "No id server '#{name}' configured in database.yml" unless ActiveRecord::Base.configurations.to_h.has_key?(name)
+      config = ActiveRecord::Base.configurations.to_h[name]
+      c = config.symbolize_keys
+
+      raise "No global_uid support for adapter #{c[:adapter]}" if c[:adapter] != 'mysql2'
+
+      Timeout.timeout(connection_timeout, ConnectionTimeoutException) do
+        ActiveRecord::Base.mysql2_connection(config)
+      end
+    rescue ConnectionTimeoutException => e
+      GlobalUid.configuration.notifier.call(ConnectionTimeoutException.new("Timed out establishing a connection to #{name}"))
+      nil
+    rescue Exception => e
+      GlobalUid.configuration.notifier.call(StandardError.new("establishing a connection to #{name}: #{e.message}"))
+      nil
+    end
+
+    def validate_connection_increment
+      db_increment = connection.select_value("SELECT @@auto_increment_increment")
+
+      if db_increment != increment_by
+        GlobalUid::Base.alert(InvalidIncrementException.new("Configured: '#{increment_by}', Found: '#{db_increment}' on '#{connection.current_database}'"))
+      end
+    end
+  end
+end

data/lib/global_uid/test_support.rb

@@ -0,0 +1,44 @@
+module GlobalUid
+  module TestSupport
+    # Tables should be created through the MigrationExtension but
+    # if you want to manually create and drop the '_id' tables,
+    # you can do so via this module
+    class << self
+      def create_uid_tables(tables: [], uid_type: nil, start_id: nil)
+        return if GlobalUid.disabled?
+
+        GlobalUid::Base.with_servers do |server|
+          tables.each do |table|
+            server.create_uid_table!(
+              name: GlobalUid::Base.id_table_from_name(table),
+              uid_type: uid_type,
+              start_id: start_id
+            )
+          end
+        end
+      end
+
+      def drop_uid_tables(tables: [])
+        return if GlobalUid.disabled?
+
+        GlobalUid::Base.with_servers do |server|
+          tables.each do |table|
+            server.drop_uid_table!(
+              name: GlobalUid::Base.id_table_from_name(table)
+            )
+          end
+        end
+      end
+
+      def recreate_uid_tables(tables: [], uid_type: nil, start_id: nil)
+        return if GlobalUid.disabled?
+
+        drop_uid_tables(tables: tables)
+        create_uid_tables(tables: tables, uid_type: nil, start_id: start_id)
+
+        # Reset the servers, clearing any allocations from memory
+        GlobalUid::Base.disconnect!
+      end
+    end
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: global_uid
 version: !ruby/object:Gem::Version
-  version: 3.7.1
+  version: 4.0.1
 platform: ruby
 authors:
 - Benjamin Quorning
 - Gabe Martin-Dempesy
 - Pierre Schambacher
 - Ben Osheroff
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-17 00:00:00.000000000 Z
+date: 2020-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -117,6 +117,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
@@ -131,6 +145,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bump
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +187,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: GUIDs for sharded models
 email:
 - bquorning@zendesk.com
@@ -170,16 +212,20 @@ extra_rdoc_files: []
 files:
 - lib/global_uid.rb
 - lib/global_uid/active_record_extension.rb
+- lib/global_uid/allocator.rb
 - lib/global_uid/base.rb
+- lib/global_uid/configuration.rb
+- lib/global_uid/error_tracker.rb
 - lib/global_uid/has_and_belongs_to_many_builder_extension.rb
 - lib/global_uid/migration_extension.rb
 - lib/global_uid/schema_dumper_extension.rb
-- lib/global_uid/server_variables.rb
+- lib/global_uid/server.rb
+- lib/global_uid/test_support.rb
 homepage: https://github.com/zendesk/global_uid
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -194,8 +240,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.1
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: GUID
 test_files: []

data/lib/global_uid/server_variables.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-# This module is good for testing and development, not so much for production.
-# 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.
-#
-# You can include this module in tests like this:
-#   GlobalUid::Base.extend(GlobalUid::ServerVariables)
-#
-module GlobalUid
-  module ServerVariables
-
-    def self.extended(base)
-      base.singleton_class.send(:alias_method, :new_connection_without_server_variables, :new_connection)
-      base.singleton_class.send(:alias_method, :new_connection, :new_connection_with_server_variables)
-    end
-
-    def new_connection_with_server_variables(name, connection_timeout, offset, increment_by)
-      con = new_connection_without_server_variables(name, connection_timeout, offset, increment_by)
-
-      if con
-        con.execute("set @@auto_increment_increment = #{increment_by}")
-        con.execute("set @@auto_increment_offset = #{offset}")
-      end
-
-      con
-    end
-
-  end
-end