just_one_lock 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd505c4500de6a9d5ac9fca007c2d204bfe2f6a5
-  data.tar.gz: 2817838753a95afe43173d5e867adfb8f9006d8d
+  metadata.gz: 4555943b102ddd4bac3f2c732d54194126999e29
+  data.tar.gz: 56f6671b415251bb76ee48aa37b68155dcf2bfc4
 SHA512:
-  metadata.gz: 661c30672498de83b0380075cb0629e9d003ae132c41f906b3a90a171adfb6a0037f95f3fed7720a21fb16a08cddd545701cd26d4a6f4d7aee9046bffbb57439
-  data.tar.gz: ccc5ae6dfde9a056f54d551f2084c7d6796318611ad01ee9c48fc3058ba8decdf4f750c2362128b57829df75ca36b8eec3877d903bb89990baaa066a0ea5f219
+  metadata.gz: 991fdcbbc3634896fb0e83a68f51fe7ffa24c90b124894a3977b5ee6779d5b76efdb3ebbd2dcce7f06a4e5a27c178ce8b973940cad8aadbf824806d6716921ab
+  data.tar.gz: 77d27fdd32f70e77a11b3ff915d9b3ee8fcd064505fac4ab7a968d9829529825b000bc6352788aeefc53956edff10f77c8ea038e89eac3e36f399d6022427c82

data/Gemfile.lock

@@ -27,5 +27,5 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.3)
   just_one_lock!
-  rake
-  rspec
+  rake (~> 10.3)
+  rspec (~> 3.0)

data/lib/just_one_lock.rb

@@ -2,22 +2,32 @@ require 'just_one_lock/version'
 require 'timeout'
 
 module JustOneLock
-  def self.filelock(lockname, options = {}, &block)
+  DEFAULT_TIMEOUT = 0.01
+  class AlreadyLocked < StandardError; end
+
+  class NullStream
+    class << self
+      def puts(str); end
+      def <<(o); self; end
+    end
+  end
+
+  def self.filelock(lockname, timeout: JustOneLock::DEFAULT_TIMEOUT, &block)
     File.open(lockname, File::RDWR|File::CREAT, 0644) do |file|
-      Timeout::timeout(options.fetch(:timeout, 60)) { file.flock(File::LOCK_EX) }
+      Timeout::timeout(timeout, JustOneLock::AlreadyLocked) { file.flock(File::LOCK_EX) }
+
       yield
     end
   end
 
-  def self.prevent_multiple_executions(lock_dir, scope, &block)
+  def self.prevent_multiple_executions(lock_dir, scope, output: JustOneLock::NullStream, timeout: JustOneLock::DEFAULT_TIMEOUT, &block)
     scope_name = scope.gsub(':', '_')
     lock_path = File.join(lock_dir, scope_name + '.lock')
 
     begin
-      return filelock(lock_path, &block)
-    rescue Timeout::Error => e
-      puts "Another process <#{scope}> already is running"
-      exit(1)
+      return filelock(lock_path, timeout: timeout, &block)
+    rescue JustOneLock::AlreadyLocked => e
+      output.puts "Another process <#{scope}> already is running"
     end
   end
 end

data/lib/just_one_lock/version.rb

@@ -1,3 +1,3 @@
 module JustOneLock
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/just_one_lock_spec.rb

@@ -9,25 +9,32 @@ describe JustOneLock do
     File.open(filename.to_s, 'w') { |f| f.write(contents) }
   end
 
-  def parallel(n = 2, templock = nil, &block)
-    Timeout::timeout(5) do
-      templock ||= Tempfile.new(['sample', '.lock'])
+  def dir_and_scope(lockpath)
+    path_segments = lockpath.split('/')
+    scope = path_segments.last
+    path_segments.delete scope
+    dir = path_segments.join('/')
+    [dir, scope]
+  end
 
+  def parallel(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, timeout: JustOneLock::DEFAULT_TIMEOUT, &block)
+    Timeout::timeout(5) do
+      dir, scope = dir_and_scope(lockpath)
       (1..n).map do
         Thread.new do
-          JustOneLock.filelock(templock, &block)
+          JustOneLock.prevent_multiple_executions(dir, scope, timeout: timeout, &block)
         end
       end.map(&:join)
     end
   end
 
-  def parallel_forks(n = 2, templock = nil, &block)
+  def parallel_forks(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, timeout: JustOneLock::DEFAULT_TIMEOUT, &block)
     Timeout::timeout(5) do
-      templock ||= Tempfile.new(['sample', '.lock'])
+      dir, scope = dir_and_scope(lockpath)
 
       (1..n).map do
         fork {
-          JustOneLock.filelock(templock, &block)
+          JustOneLock.prevent_multiple_executions(dir, scope, timeout: timeout, &block)
         }
       end.map do |pid|
         Process.waitpid(pid)
@@ -66,19 +73,18 @@ describe JustOneLock do
 
     parallel(2) do
       value = answer
-      sleep 0.1
+      sleep(JustOneLock::DEFAULT_TIMEOUT / 2)
       answer = value + 21
     end
 
     expect(answer).to eq(42)
   end
 
-  it 'handels high amount of concurrent tasks' do
+  it 'handles high amount of concurrent tasks' do
     answer = 0
 
     parallel(100) do
       value = answer
-      sleep 0.001
       answer = value + 1
     end
 
@@ -86,33 +92,29 @@ describe JustOneLock do
   end
 
   it 'creates lock file on disk during block execution' do
-    Dir.mktmpdir do |dir|
-      lockpath = File.join(dir, 'sample.lock')
-      parallel(2, lockpath) do
-        expect(File.exist?(lockpath)).to eq(true)
-      end
+    lockpath = Tempfile.new(['sample', '.lock']).path
+    parallel(2, lockpath: lockpath) do
+      expect(File.exist?(lockpath)).to eq(true)
     end
   end
 
   it 'runs in parallel without race condition' do
-    Dir.mktmpdir do |dir|
-      lockpath = File.join(dir, 'sample.lock')
+    lockpath = Tempfile.new(['sample', '.lock']).path
 
-      answer = 0
-
-      begin
-        JustOneLock.filelock(lockpath) do
-          raise '42'
-        end
-      rescue RuntimeError
-      end
+    answer = 0
 
+    begin
       JustOneLock.filelock(lockpath) do
-        answer += 42
+        raise '42'
       end
+    rescue RuntimeError
+    end
 
-      expect(answer).to eq(42)
+    JustOneLock.filelock(lockpath) do
+      answer += 42
     end
+
+    expect(answer).to eq(42)
   end
 
   it 'times out after specified number of seconds' do
@@ -139,7 +141,7 @@ describe JustOneLock do
         JustOneLock.filelock lockpath, timeout: 0.001 do
           answer = 0
         end
-      end.to raise_error(Timeout::Error)
+      end.to raise_error(JustOneLock::AlreadyLocked)
 
       expect(answer).to eq(42)
     end
@@ -153,7 +155,7 @@ describe JustOneLock do
 
       parallel_forks(6) do
         number = File.read('/tmp/number.txt').to_i
-        sleep 0.3
+        sleep(JustOneLock::DEFAULT_TIMEOUT / 100)
         write('/tmp/number.txt', (number + 7).to_s)
       end
 
@@ -165,46 +167,47 @@ describe JustOneLock do
     it 'should handle heavy forking' do
       write('/tmp/number.txt', '0')
 
-      parallel_forks(100) do
+      FORKS_NUMBER = 100
+      parallel_forks(FORKS_NUMBER, timeout: 1) do
         number = File.read('/tmp/number.txt').to_i
-        sleep 0.001
         write('/tmp/number.txt', (number + 1).to_s)
       end
 
       number = File.read('/tmp/number.txt').to_i
 
-      expect(number).to eq(100)
+      expect(number).to eq(FORKS_NUMBER)
     end
 
     it 'should unblock files when killing processes' do
-      Dir.mktmpdir do |dir|
-        lockpath = File.join(dir, 'sample.lock')
-
-        Dir.mktmpdir do |dir|
-          pid = fork {
-            JustOneLock.filelock lockpath do
-              sleep 10
-            end
-          }
+      lockpath = Tempfile.new(['sample', '.lock']).path
+      dir, scope = dir_and_scope(lockpath)
 
-          sleep 0.5
+      Dir.mktmpdir do |dir|
+        pid = fork {
+          JustOneLock.prevent_multiple_executions(dir, scope) do
+            sleep 10
+          end
+        }
 
-          answer = 0
+        Timeout::timeout(1) do
+          while !File.exist?(lockpath)
+            sleep 0.1
+          end
+        end
 
-          thread = Thread.new {
-            JustOneLock.filelock lockpath do
-              answer += 42
-            end
-          }
+        answer = 0
 
-          sleep 0.5
+        thread = Thread.new {
+          JustOneLock.prevent_multiple_executions(dir, scope) do
+            answer += 42
+          end
+        }
 
-          expect(answer).to eq(0)
-          Process.kill(9, pid)
-          thread.join
+        expect(answer).to eq(0)
+        Process.kill(9, pid)
+        thread.join
 
-          expect(answer).to eq(42)
-        end
+        expect(answer).to eq(42)
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: just_one_lock
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Adam Stankiewicz, Yury Kotov