activejob-locking 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc5170f734ea482c37205c31fd82389b4a67225c
-  data.tar.gz: 9a54a53cbd88f1da58824e05b1c51502020787e0
+  metadata.gz: 7cd905211ccba06fbbf2fac424009b84ab5fe769
+  data.tar.gz: c7c970994a0e5f3ad816c7b5da8ca28722d4596b
 SHA512:
-  metadata.gz: f7c86564b3c0d43210e7fe90abb524d4a8e7151113ea950edf5625590986e954a46e8be3da0f24118ff43ac81064c9e85929da66a4af9e52d133aa1ab3e912fb
-  data.tar.gz: 2e13fe88cfcb4cba7cc953986d29e076b704fad7400e6b59075f3fd491f7fb785428f6edf9be97fad5ff2b6858f37ffc3367282ff2b0d9e59e8986a6c5052ed1
+  metadata.gz: 1f5f4247c8f15cd41dc0692f1a638a775229404620cee8a6318e4c410dca20e922762145fe5af991c24d71cfacc045ec9dd53f266b4bfa6d9cf22bbd4eed0e6b
+  data.tar.gz: 7f9a485dac7c34835b7209ed3c7e2736d02ef735a8f6fc6575f8bdb9dcd2831289abe19a9d7c0823960b24a1b6eb6f74b231ac9c7408501abd9437b24d7bc912

data/HISTORY.md

@@ -1,6 +1,10 @@
 ## 0.3.0 (2017-06-21)
 
-- Change lock_key signature
+- Cleanup handling of hosts
+
+## 0.3.0 (2017-06-21)
+
+- Change lock_key signature to match perform signature
 
 ## 0.2.0 (2017-06-20)
 

data/README.md

@@ -159,15 +159,15 @@ class ExampleJob < ActiveJob::Base
 end
 ```
 
-### Host
+### Hosts
 
-The host(s) of the distributed system. This format will be dependent on the locking gem, so please read its 
-documentation.  
+An array of hosts for the distributed system. This format is dependent on the locking gem, but generally is a url or an existing Memcache or Redis
+connection. Please refer to the appropriate locking gem's documentation documentation.  
 
 Globally update:
 
 ```ruby
-ActiveJob::Locking.options.hosts = 'localhost'
+ActiveJob::Locking.options.hosts = ['localhost']
 ```
 Locally update:
 
@@ -175,7 +175,7 @@ Locally update:
 class ExampleJob < ActiveJob::Base
   include ActiveJob::Locking::Serialized
 
-  self.hosts = 'localhost'
+  self.hosts = ['localhost']
 end
 ```
 
@@ -226,7 +226,6 @@ class ExampleJob < ActiveJob::Base
 end
 ```
 
-
 ### AdapterOptions
 
 This is a hash table of options that should be sent to the lock gem when it is instantiated. Read the lock 

data/lib/activejob-locking.rb

@@ -10,7 +10,7 @@ require 'activejob/locking/options'
 module ActiveJob
   module Locking
     @options = ActiveJob::Locking::Options.new(adapter: ActiveJob::Locking::Adapters::Memory,
-                                               hosts: 'localhost',
+                                               hosts: ['localhost'],
                                                lock_time: 100,
                                                lock_acquire_time: 1,
                                                adapter_options: {})

data/lib/activejob/locking/adapters/base.rb

@@ -1,32 +1,32 @@
-module ActiveJob
-  module Locking
-    module Adapters
-      class Base
-        attr_reader :key, :options, :lock_manager
-        attr_accessor :lock_token
-
-        def initialize(key, options)
-          @key = key
-          @options = options
-          @lock_manager = self.create_lock_manager
-        end
-
-        def create_lock_manager
-          raise('Subclass must implement')
-        end
-
-        def lock
-          raise('Subclass must implement')
-        end
-
-        def unlock
-          raise('Subclass must implement')
-        end
-
-        def refresh_lock!(refresh)
-          raise('Subclass must implement')
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Adapters
+      class Base
+        attr_reader :key, :options, :lock_manager
+        attr_accessor :lock_token
+
+        def initialize(key, options)
+          @key = key
+          @options = options
+          @lock_manager = self.create_lock_manager
+        end
+
+        def create_lock_manager
+          raise('Subclass must implement')
+        end
+
+        def lock
+          raise('Subclass must implement')
+        end
+
+        def unlock
+          raise('Subclass must implement')
+        end
+
+        def refresh_lock!(refresh)
+          raise('Subclass must implement')
+        end
+      end
+    end
+  end
 end

data/lib/activejob/locking/adapters/memory.rb

@@ -1,58 +1,58 @@
-module ActiveJob
-  module Locking
-    module Adapters
-      class Memory < Base
-        @hash = Hash.new
-        @mutex = Mutex.new
-
-        def self.lock(key)
-          @mutex.synchronize do
-            if @hash[key]
-              false
-            else
-              @hash[key] = Time.now
-            end
-          end
-        end
-
-        def self.unlock(key)
-          @mutex.synchronize do
-            @hash.delete(key)
-          end
-        end
-
-        def self.locked?(key)
-          @mutex.synchronize do
-            @hash.include?(key)
-          end
-        end
-
-        def self.reset
-          @mutex.synchronize do
-            @hash = Hash.new
-          end
-        end
-
-        def create_lock_manager
-        end
-
-        def lock
-          finish = Time.now + self.options.lock_acquire_time
-          sleep_time = [5, self.options.lock_acquire_time / 5].min
-
-          begin
-            lock = self.class.lock(key)
-            return lock if lock
-            sleep(sleep_time)
-          end while Time.now < finish
-
-          false
-        end
-
-        def unlock
-          self.class.unlock(self.key)
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Adapters
+      class Memory < Base
+        @hash = Hash.new
+        @mutex = Mutex.new
+
+        def self.lock(key)
+          @mutex.synchronize do
+            if @hash[key]
+              false
+            else
+              @hash[key] = Time.now
+            end
+          end
+        end
+
+        def self.unlock(key)
+          @mutex.synchronize do
+            @hash.delete(key)
+          end
+        end
+
+        def self.locked?(key)
+          @mutex.synchronize do
+            @hash.include?(key)
+          end
+        end
+
+        def self.reset
+          @mutex.synchronize do
+            @hash = Hash.new
+          end
+        end
+
+        def create_lock_manager
+        end
+
+        def lock
+          finish = Time.now + self.options.lock_acquire_time
+          sleep_time = [5, self.options.lock_acquire_time / 5].min
+
+          begin
+            lock = self.class.lock(key)
+            return lock if lock
+            sleep(sleep_time)
+          end while Time.now < finish
+
+          false
+        end
+
+        def unlock
+          self.class.unlock(self.key)
+        end
+      end
+    end
+  end
 end

data/lib/activejob/locking/adapters/redis-semaphore.rb

@@ -1,26 +1,26 @@
-require 'redis-semaphore'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class RedisSemaphore < Base
-        def create_lock_manager
-          mapped_options = {host: self.options.hosts,
-                            resources: 1,
-                            stale_client_timeout: self.options.lock_time}.merge(self.options.adapter_options)
-
-          Redis::Semaphore.new(self.key, mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock(self.options.lock_acquire_time)
-        end
-
-        def unlock
-          self.lock_manager.signal(self.lock_token)
-          self.lock_token = nil
-        end
-      end
-    end
-  end
-end
+require 'redis-semaphore'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class RedisSemaphore < Base
+        def create_lock_manager
+          mapped_options = {host: self.options.hosts.first,
+                            resources: 1,
+                            stale_client_timeout: self.options.lock_time}.merge(self.options.adapter_options)
+
+          Redis::Semaphore.new(self.key, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock(self.options.lock_acquire_time)
+        end
+
+        def unlock
+          self.lock_manager.signal(self.lock_token)
+          self.lock_token = nil
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/adapters/redlock.rb

@@ -1,26 +1,26 @@
-require 'redlock'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class Redlock < Base
-        def create_lock_manager
-          mapped_options = self.options.adapter_options
-          mapped_options[:retry_count] = 2 # Try to get the lock and then try again when timeout is expiring--
-          mapped_options[:retry_delay] = self.options.lock_acquire_time * 1000 # convert from seconds to milliseconds
-
-          ::Redlock::Client.new(Array(self.options.hosts), mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock(self.key, self.options.lock_time * 1000)
-        end
-
-        def unlock
-          self.lock_manager.unlock(self.lock_token)
-          self.lock_token = nil
-        end
-      end
-    end
-  end
-end
+require 'redlock'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class Redlock < Base
+        def create_lock_manager
+          mapped_options = self.options.adapter_options
+          mapped_options[:retry_count] = 2 # Try to get the lock and then try again when timeout is expiring--
+          mapped_options[:retry_delay] = self.options.lock_acquire_time * 1000 # convert from seconds to milliseconds
+
+          ::Redlock::Client.new(self.options.hosts, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock(self.key, self.options.lock_time * 1000)
+        end
+
+        def unlock
+          self.lock_manager.unlock(self.lock_token)
+          self.lock_token = nil
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/adapters/suo-redis.rb

@@ -1,25 +1,25 @@
-require 'suo'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class SuoRedis < Base
-        def create_lock_manager
-          mapped_options = {connection: {host: self.options.hosts},
-                            stale_lock_expiration: self.options.lock_time,
-                            acquisition_timeout: self.options.lock_acquire_time}
-
-          Suo::Client::Redis.new(self.key, mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock
-        end
-
-        def unlock
-          self.lock_manager.unlock(self.lock_token)
-        end
-      end
-    end
-  end
-end
+require 'suo'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class SuoRedis < Base
+        def create_lock_manager
+          mapped_options = {connection: {host: self.options.hosts.first},
+                            stale_lock_expiration: self.options.lock_time,
+                            acquisition_timeout: self.options.lock_acquire_time}
+
+          Suo::Client::Redis.new(self.key, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock
+        end
+
+        def unlock
+          self.lock_manager.unlock(self.lock_token)
+        end
+      end
+    end
+  end
+end

data/test/jobs/fail_job.rb

@@ -1,15 +1,15 @@
-class FailJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    raise(ArgumentError, 'Job failed')
-  end
+class FailJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    raise(ArgumentError, 'Job failed')
+  end
 end

data/test/jobs/serial_job.rb

@@ -1,15 +1,15 @@
-class SerialJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class SerialJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/jobs/unique_job.rb

@@ -1,15 +1,15 @@
-class UniqueJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class UniqueJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/test_suite.rb

@@ -1,12 +1,12 @@
-%w(
-  test_serialized_memory
-  test_serialized_redis_semaphore
-  test_serialized_redlock
-  test_serialized_suo_redis
-  test_unique_memory
-  test_unique_redis_semaphore
-  test_unique_redlock
-  test_unique_suo_redis
-).each do |test|
-  require File.expand_path("../#{test}", __FILE__)
-end
+%w(
+  test_serialized_memory
+  test_serialized_redis_semaphore
+  test_serialized_redlock
+  test_serialized_suo_redis
+  test_unique_memory
+  test_unique_redis_semaphore
+  test_unique_redlock
+  test_unique_suo_redis
+).each do |test|
+  require File.expand_path("../#{test}", __FILE__)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob-locking
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Charlie Savage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-21 00:00:00.000000000 Z
+date: 2017-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob