just_one_lock 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4555943b102ddd4bac3f2c732d54194126999e29
-  data.tar.gz: 56f6671b415251bb76ee48aa37b68155dcf2bfc4
+  metadata.gz: ef790c43dd30dabc1e75e662d8e042ff0a49c08f
+  data.tar.gz: 77ef1490b78280b803160512b96beaa8aeea376f
 SHA512:
-  metadata.gz: 991fdcbbc3634896fb0e83a68f51fe7ffa24c90b124894a3977b5ee6779d5b76efdb3ebbd2dcce7f06a4e5a27c178ce8b973940cad8aadbf824806d6716921ab
-  data.tar.gz: 77d27fdd32f70e77a11b3ff915d9b3ee8fcd064505fac4ab7a968d9829529825b000bc6352788aeefc53956edff10f77c8ea038e89eac3e36f399d6022427c82
+  metadata.gz: 7f33614e6f935dfbb3040e64f09590342988ebe8566ebaca24c315d180bd73040723d165f9ede1c1804fedde2285c4d9b257ac9924ddbc84ae5d2cf94db8f477
+  data.tar.gz: 68a3d589c4545bdcba5e5467861d8120687e69b1b7438e6b0c5f6b86f7f0854d3674c68236f824da86e7e9f60c1151dad914100ff510beb5e275b20ea1209ee8

data/.gitignore

@@ -1,2 +1,3 @@
 *.swp
 tags
+*.gem

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    just_one_lock (0.0.1)
+    just_one_lock (0.0.2)
 
 GEM
   remote: https://rubygems.org/

data/lib/just_one_lock.rb

@@ -1,33 +1,36 @@
 require 'just_one_lock/version'
-require 'timeout'
+require 'just_one_lock/blocking'
+require 'just_one_lock/non_blocking'
 
 module JustOneLock
-  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(timeout, JustOneLock::AlreadyLocked) { file.flock(File::LOCK_EX) }
+  @files = {}
 
-      yield
+  def self.delete_unlocked_files
+    @files.each do |path, f|
+      if File.exists?(path) && f.closed?
+        File.delete(path) rescue nil
+      end
     end
   end
 
-  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')
+  private
 
-    begin
-      return filelock(lock_path, timeout: timeout, &block)
-    rescue JustOneLock::AlreadyLocked => e
-      output.puts "Another process <#{scope}> already is running"
-    end
+  def self.write_pid(f)
+    f.rewind
+    f.write(Process.pid)
+    f.flush
+    f.truncate(f.pos)
+  end
+
+  def self.run(f, lockname, &block)
+    @files[lockname] = f
+    write_pid(f)
+    block.call
   end
 end

data/lib/just_one_lock/blocking.rb

@@ -0,0 +1,42 @@
+require 'timeout'
+
+module JustOneLock::Blocking
+  DEFAULT_TIMEOUT = 1
+  class AlreadyLocked < StandardError; end
+
+  def self.filelock(
+    lockname,
+    timeout: JustOneLock::Blocking::DEFAULT_TIMEOUT,
+    delete_files: true,
+    &block
+  )
+    result = nil
+    File.open(lockname, File::RDWR|File::CREAT, 0644) do |f|
+      Timeout::timeout(timeout, JustOneLock::Blocking::AlreadyLocked) { f.flock(File::LOCK_EX) }
+
+      result = JustOneLock.run(f, lockname, &block)
+    end
+
+    JustOneLock.delete_unlocked_files if delete_files
+    result
+  end
+
+  def self.prevent_multiple_executions(
+    lock_dir,
+    scope,
+    output: JustOneLock::NullStream,
+    timeout: JustOneLock::Blocking::DEFAULT_TIMEOUT,
+    delete_files: true,
+    &block
+  )
+    scope_name = scope.gsub(':', '_')
+    lock_path = File.join(lock_dir, scope_name + '.lock')
+
+    begin
+      return filelock(lock_path, timeout: timeout, delete_files: delete_files, &block)
+    rescue JustOneLock::Blocking::AlreadyLocked => e
+      output.puts "Another process <#{scope}> already is running"
+    end
+  end
+end
+

data/lib/just_one_lock/non_blocking.rb

@@ -0,0 +1,37 @@
+module JustOneLock::NonBlocking
+  def self.filelock(
+    lockname,
+    delete_files: true,
+    &block
+  )
+    result = nil
+
+    File.open(lockname, File::RDWR|File::CREAT, 0644) do |f|
+      if f.flock(File::LOCK_NB|File::LOCK_EX)
+        result = JustOneLock.run(f, lockname, &block)
+      end
+    end
+
+    JustOneLock.delete_unlocked_files if delete_files
+    result
+  end
+
+
+  def self.prevent_multiple_executions(
+    lock_dir,
+    scope,
+    output: JustOneLock::NullStream,
+    &block
+  )
+    scope_name = scope.gsub(':', '_')
+    lock_path = File.join(lock_dir, scope_name + '.lock')
+
+    was_executed = filelock(lock_path, &block)
+
+    unless was_executed
+      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.2"
+  VERSION = '0.0.3'
 end

data/spec/just_one_lock/blocking_spec.rb

@@ -0,0 +1,80 @@
+require 'just_one_lock'
+require 'tempfile'
+require 'timeout'
+require 'just_one_lock/locking_object'
+
+describe JustOneLock::Blocking do
+  it_behaves_like 'a locking object'
+
+  def parallel(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, timeout: JustOneLock::Blocking::DEFAULT_TIMEOUT, &block)
+    Timeout::timeout(5) do
+      dir, scope = dir_and_scope(lockpath)
+      (1..n).map do
+        Thread.new do
+          JustOneLock::Blocking.prevent_multiple_executions(dir, scope, timeout: timeout, delete_files: false, &block)
+        end
+      end.map(&:join)
+    end
+
+    JustOneLock.delete_unlocked_files
+  end
+
+  def parallel_forks(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, timeout: JustOneLock::Blocking::DEFAULT_TIMEOUT, &block)
+    Timeout::timeout(5) do
+      dir, scope = dir_and_scope(lockpath)
+
+      (1..n).map do
+        fork {
+          JustOneLock::Blocking.prevent_multiple_executions(dir, scope, timeout: timeout, delete_files: false, &block)
+        }
+      end.map do |pid|
+        Process.waitpid(pid)
+      end
+    end
+
+    JustOneLock.delete_unlocked_files
+  end
+
+  # Java doesn't support forking
+  if RUBY_PLATFORM != 'java'
+    it 'should work for multiple processes' do
+      write('/tmp/number.txt', '0')
+
+      parallel_forks(6, timeout: 10) do
+        number = File.read('/tmp/number.txt').to_i
+        sleep(JustOneLock::Blocking::DEFAULT_TIMEOUT / 100)
+        write('/tmp/number.txt', (number + 7).to_s)
+      end
+
+      number = File.read('/tmp/number.txt').to_i
+
+      expect(number).to eq(42)
+    end
+
+    it 'should handle heavy forking' do
+      write('/tmp/number.txt', '0')
+
+      FORKS_NUMBER = 100
+      parallel_forks(FORKS_NUMBER, timeout: 10) do
+        number = File.read('/tmp/number.txt').to_i
+        write('/tmp/number.txt', (number + 1).to_s)
+      end
+
+      number = File.read('/tmp/number.txt').to_i
+
+      expect(number).to eq(FORKS_NUMBER)
+    end
+
+    it 'handles high amount of concurrent tasks' do
+      answer = 0
+
+      parallel(100, timeout: JustOneLock::Blocking::DEFAULT_TIMEOUT * 10) do
+        value = answer
+        answer = value + 1
+      end
+
+      expect(answer).to eq(100)
+    end
+  end
+end
+

data/spec/just_one_lock/locking_object.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+shared_examples 'a locking object' do
+  it 'runs simple ruby block as usual' do
+    Dir.mktmpdir do |lock_dir|
+      lockpath = File.join(lock_dir, 'sample.lock')
+      answer = 0
+
+      JustOneLock::Blocking.filelock lockpath do
+        answer += 42
+      end
+
+      expect(answer).to eq(42)
+    end
+  end
+
+  it 'returns value returned by block' do
+    Dir.mktmpdir do |lock_dir|
+      lockpath = File.join(lock_dir, 'sample.lock')
+      answer = 0
+
+      answer = JustOneLock::Blocking.filelock lockpath do
+        42
+      end
+
+      expect(answer).to eq(42)
+    end
+  end
+
+  it 'runs in parallel without race condition' do
+    answer = 0
+
+    parallel(2) do
+      value = answer
+      sleep(JustOneLock::Blocking::DEFAULT_TIMEOUT / 2)
+      answer = value + 21
+    end
+
+    expect(answer).to eq(42)
+  end
+
+  it 'creates lock file on disk during block execution' do
+    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
+    lockpath = Tempfile.new(['sample', '.lock']).path
+
+    answer = 0
+
+    begin
+      JustOneLock::Blocking.filelock(lockpath) do
+        raise '42'
+      end
+    rescue RuntimeError
+    end
+
+    JustOneLock::Blocking.filelock(lockpath) do
+      answer += 42
+    end
+
+    expect(answer).to eq(42)
+  end
+
+  it 'times out after specified number of seconds' do
+    Dir.mktmpdir do |lock_dir|
+      lockpath = File.join(lock_dir, 'sample.lock')
+
+      answer = 42
+      locked = false
+
+      Thread.new do
+        JustOneLock::Blocking.filelock lockpath do
+          locked = true
+          sleep 20
+        end
+      end
+
+      Timeout::timeout(1) do
+        while locked == false
+          sleep 0.1
+        end
+      end
+
+      expect do
+        JustOneLock::Blocking.filelock lockpath, timeout: 0.001 do
+          answer = 0
+        end
+      end.to raise_error(JustOneLock::Blocking::AlreadyLocked)
+
+      expect(answer).to eq(42)
+    end
+  end
+
+  # Java doesn't support forking
+  if RUBY_PLATFORM != 'java'
+
+    it 'should unblock files when killing processes' do
+      lockpath = Tempfile.new(['sample', '.lock']).path
+      dir, scope = dir_and_scope(lockpath)
+
+      pid = fork {
+        JustOneLock::Blocking.prevent_multiple_executions(lock_dir, scope) do
+          sleep 10
+        end
+      }
+
+      Timeout::timeout(1) do
+        while !File.exist?(lockpath)
+          sleep 0.1
+        end
+      end
+
+      answer = 0
+
+      thread = Thread.new {
+        JustOneLock::Blocking.prevent_multiple_executions(dir, scope) do
+          answer += 42
+        end
+      }
+
+      expect(answer).to eq(0)
+      Process.kill(9, pid)
+      thread.join
+
+      expect(answer).to eq(42)
+    end
+
+    it 'should handle Pathname as well as string path' do
+      Dir.mktmpdir do |lock_dir|
+        lockpath = Pathname.new(File.join(lock_dir, 'sample.lock'))
+
+        answer = 0
+        JustOneLock::Blocking.filelock lockpath do
+          answer += 42
+        end
+
+        expect(answer).to eq(42)
+      end
+    end
+  end
+
+  # It failed for 1.8.7  (cannot convert to String)
+  it 'works for Tempfile' do
+    answer = 0
+
+    JustOneLock::Blocking.filelock Tempfile.new(['sample', '.lock']) do
+      answer += 42
+    end
+
+    expect(answer).to eq(42)
+  end
+
+  # If implemented the wrong way lock is created elsewhere
+  it 'creates file with exact path provided' do
+    filename = "/tmp/awesome-lock-#{rand}.lock"
+
+    JustOneLock::Blocking.filelock filename, delete_files: false do
+    end
+
+    expect(File.exist?(filename)).to eq(true)
+  end
+end
+
+

data/spec/just_one_lock/non_blocking_spec.rb

@@ -0,0 +1,38 @@
+require 'just_one_lock'
+require 'tempfile'
+require 'timeout'
+require 'just_one_lock/locking_object'
+
+describe JustOneLock::NonBlocking do
+  it_behaves_like 'a locking object'
+
+  def parallel(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, &block)
+    Timeout::timeout(5) do
+      dir, scope = dir_and_scope(lockpath)
+      (1..n).map do
+        Thread.new do
+          JustOneLock::Blocking.prevent_multiple_executions(dir, scope, delete_files: false, &block)
+        end
+      end.map(&:join)
+    end
+
+    JustOneLock.delete_unlocked_files
+  end
+
+  def parallel_forks(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, &block)
+    Timeout::timeout(5) do
+      dir, scope = dir_and_scope(lockpath)
+
+      (1..n).map do
+        fork {
+          JustOneLock::Blocking.prevent_multiple_executions(dir, scope, delete_files: false, &block)
+        }
+      end.map do |pid|
+        Process.waitpid(pid)
+      end
+    end
+
+    JustOneLock.delete_unlocked_files
+  end
+end
+

data/spec/just_one_lock_spec.rb

@@ -3,247 +3,4 @@ require 'tempfile'
 require 'timeout'
 
 describe JustOneLock do
-
-  # Helper because File.write won't work for older Ruby
-  def write(filename, contents)
-    File.open(filename.to_s, 'w') { |f| f.write(contents) }
-  end
-
-  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.prevent_multiple_executions(dir, scope, timeout: timeout, &block)
-        end
-      end.map(&:join)
-    end
-  end
-
-  def parallel_forks(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
-        fork {
-          JustOneLock.prevent_multiple_executions(dir, scope, timeout: timeout, &block)
-        }
-      end.map do |pid|
-        Process.waitpid(pid)
-      end
-    end
-  end
-
-  it 'runs simple ruby block as usual' do
-    Dir.mktmpdir do |dir|
-      lockpath = File.join(dir, 'sample.lock')
-      answer = 0
-
-      JustOneLock.filelock lockpath do
-        answer += 42
-      end
-
-      expect(answer).to eq(42)
-    end
-  end
-
-  it 'returns value returned by block' do
-    Dir.mktmpdir do |dir|
-      lockpath = File.join(dir, 'sample.lock')
-      answer = 0
-
-      answer = JustOneLock.filelock lockpath do
-        42
-      end
-
-      expect(answer).to eq(42)
-    end
-  end
-
-  it 'runs in parallel without race condition' do
-    answer = 0
-
-    parallel(2) do
-      value = answer
-      sleep(JustOneLock::DEFAULT_TIMEOUT / 2)
-      answer = value + 21
-    end
-
-    expect(answer).to eq(42)
-  end
-
-  it 'handles high amount of concurrent tasks' do
-    answer = 0
-
-    parallel(100) do
-      value = answer
-      answer = value + 1
-    end
-
-    expect(answer).to eq(100)
-  end
-
-  it 'creates lock file on disk during block execution' do
-    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
-    lockpath = Tempfile.new(['sample', '.lock']).path
-
-    answer = 0
-
-    begin
-      JustOneLock.filelock(lockpath) do
-        raise '42'
-      end
-    rescue RuntimeError
-    end
-
-    JustOneLock.filelock(lockpath) do
-      answer += 42
-    end
-
-    expect(answer).to eq(42)
-  end
-
-  it 'times out after specified number of seconds' do
-    Dir.mktmpdir do |dir|
-      lockpath = File.join(dir, 'sample.lock')
-
-      answer = 42
-      locked = false
-
-      Thread.new do
-        JustOneLock.filelock lockpath do
-          locked = true
-          sleep 20
-        end
-      end
-
-      Timeout::timeout(1) do
-        while locked == false
-          sleep 0.1
-        end
-      end
-
-      expect do
-        JustOneLock.filelock lockpath, timeout: 0.001 do
-          answer = 0
-        end
-      end.to raise_error(JustOneLock::AlreadyLocked)
-
-      expect(answer).to eq(42)
-    end
-  end
-
-  # Java doesn't support forking
-  if RUBY_PLATFORM != 'java'
-
-    it 'should work for multiple processes' do
-      write('/tmp/number.txt', '0')
-
-      parallel_forks(6) do
-        number = File.read('/tmp/number.txt').to_i
-        sleep(JustOneLock::DEFAULT_TIMEOUT / 100)
-        write('/tmp/number.txt', (number + 7).to_s)
-      end
-
-      number = File.read('/tmp/number.txt').to_i
-
-      expect(number).to eq(42)
-    end
-
-    it 'should handle heavy forking' do
-      write('/tmp/number.txt', '0')
-
-      FORKS_NUMBER = 100
-      parallel_forks(FORKS_NUMBER, timeout: 1) do
-        number = File.read('/tmp/number.txt').to_i
-        write('/tmp/number.txt', (number + 1).to_s)
-      end
-
-      number = File.read('/tmp/number.txt').to_i
-
-      expect(number).to eq(FORKS_NUMBER)
-    end
-
-    it 'should unblock files when killing processes' do
-      lockpath = Tempfile.new(['sample', '.lock']).path
-      dir, scope = dir_and_scope(lockpath)
-
-      Dir.mktmpdir do |dir|
-        pid = fork {
-          JustOneLock.prevent_multiple_executions(dir, scope) do
-            sleep 10
-          end
-        }
-
-        Timeout::timeout(1) do
-          while !File.exist?(lockpath)
-            sleep 0.1
-          end
-        end
-
-        answer = 0
-
-        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(42)
-      end
-    end
-
-    it 'should handle Pathname as well as string path' do
-      Dir.mktmpdir do |dir|
-        lockpath = Pathname.new(File.join(dir, 'sample.lock'))
-
-        answer = 0
-        JustOneLock.filelock lockpath do
-          answer += 42
-        end
-
-        expect(answer).to eq(42)
-      end
-    end
-
-  end
-
-  # It failed for 1.8.7  (cannot convert to String)
-  it 'works for Tempfile' do
-    answer = 0
-
-    JustOneLock.filelock Tempfile.new(['sample', '.lock']) do
-      answer += 42
-    end
-
-    expect(answer).to eq(42)
-  end
-
-  # If implemented the wrong way lock is created elsewhere
-  it 'creates file with exact path provided' do
-    filename = "/tmp/awesome-lock-#{rand}.lock"
-
-    JustOneLock.filelock filename do
-    end
-
-    expect(File.exist?(filename)).to eq(true)
-  end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+def lock_dir
+  '/tmp'
+end
+
+# Helper because File.write won't work for older Ruby
+def write(filename, contents)
+  File.open(filename.to_s, 'w') { |f| f.write(contents) }
+end
+
+def dir_and_scope(lockpath)
+  path_segments = lockpath.split('/')
+  scope = path_segments.last
+  path_segments.delete scope
+  dir = path_segments.join('/')
+  [dir, scope]
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: just_one_lock
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Adam Stankiewicz, Yury Kotov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,8 +69,14 @@ files:
 - Rakefile
 - just_one_lock.gemspec
 - lib/just_one_lock.rb
+- lib/just_one_lock/blocking.rb
+- lib/just_one_lock/non_blocking.rb
 - lib/just_one_lock/version.rb
+- spec/just_one_lock/blocking_spec.rb
+- spec/just_one_lock/locking_object.rb
+- spec/just_one_lock/non_blocking_spec.rb
 - spec/just_one_lock_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/beorc/just_one_lock
 licenses:
 - MIT
@@ -96,4 +102,8 @@ signing_key:
 specification_version: 4
 summary: Simple solution to prevent multiple executions using flock
 test_files:
+- spec/just_one_lock/blocking_spec.rb
+- spec/just_one_lock/locking_object.rb
+- spec/just_one_lock/non_blocking_spec.rb
 - spec/just_one_lock_spec.rb
+- spec/spec_helper.rb