just_one_lock 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cbc796000346c2d5e41e9808e7bf8b1e50ef421
-  data.tar.gz: c919c93fdd387737c7349f2d2e1607550c235a24
+  metadata.gz: 6ac57ab6070d88fa87e098e760f0c8a85d9533b3
+  data.tar.gz: b22dab3d97237b42ad75ec74f75a9e6bf45ecaf4
 SHA512:
-  metadata.gz: fdd1f6a2be4aea0132d54d0b05d29512cff1f913b2240ec6c99896cc93bfc8e9e04c5dc5d24bba11fc2a6e665b65d0528e3bf55581f32f97ed4de6bd8ac68eeb
-  data.tar.gz: d9bb70c3362c62ac90ce25755199a375d76dd0e660c278691a1a37ddd56d6d903b0ec610a13d4e0752a1d3975e7d2e7fc5ed056c0448c12c445a6778ea79fa1f
+  metadata.gz: d3a2a7b9d9f81213e1e5bc40339c47050fcf2a08e41180817085802b13875e9761c98fadc211c8039ec0acfdb551e0900c1a323c7ba5cf0b152f6b9bee6f13ec
+  data.tar.gz: d07707b5948b99309c0d3de0abb09122de3312d643eabd4882a4c6c44187616d365fc10c68dbb1bc885aec1af3f9e73477de47233d70198ba97c653771491f92

data/bin/just_one_lock

@@ -12,42 +12,29 @@ version JustOneLock::VERSION
 
 flag [:l,:lock_dir], default_value: '/tmp'
 flag [:s,:scope]
+flag [:t,:timeout], desc: 'Timeout in seconds'
 
-pre do |global_options, command, options, args|
-  $lock_dir = global_options[:lock_dir]
-  $scope = global_options[:scope]
-  $command_to_run = args.first
-end
-
-desc 'Execute system command using blocking lock'
-command :blocking do |c|
-  c.flag [:t,:timeout], desc: 'Timeout in seconds'
-
+desc 'Execute system command'
+command :exec do |c|
   c.action do |global_options, options, args|
-    timeout = options[:timeout]
-    timeout = timeout.to_i if timeout
-
-    JustOneLock::Blocking.prevent_multiple_executions(
-      $lock_dir,
-      $scope,
-      output: $stdout,
-      timeout: timeout
-    ) do
-      system $command_to_run
+    JustOneLock.world.directory = global_options[:lock_dir]
+    scope = global_options[:scope]
+    timeout = global_options[:timeout].to_f
+    command_to_run = args.first
+
+    if timeout > 0
+      locker = JustOneLock::BlockingLocker.new(timeout: timeout)
+    else
+      locker = JustOneLock::NonBlockingLocker.new
     end
-  end
-end
 
-desc 'Execute system command'
-command :non_blocking do |c|
-  c.action do |global_options, options, args|
-    JustOneLock::NonBlocking.prevent_multiple_executions($lock_dir, $scope, output: $stdout) do
-      system $command_to_run
+    JustOneLock::prevent_multiple_executions(locker, scope) do
+      system command_to_run
     end
   end
 end
 
-default_command :non_blocking
+default_command :exec
 
 exit run(ARGV)
 

data/lib/just_one_lock/base_locker.rb

@@ -0,0 +1,27 @@
+class JustOneLock::BaseLocker
+  def already_locked(scope)
+    msg = "Another process <#{scope}> already is running"
+    JustOneLock.puts msg
+    raise JustOneLock::AlreadyLocked, msg
+  end
+
+  private
+
+  def write_pid(f)
+    f.rewind
+    f.write(Process.pid)
+    f.flush
+    f.truncate(f.pos)
+  end
+
+  def run(f, path, &block)
+    write_pid(f)
+
+    JustOneLock.before_lock(path, f)
+    result = block.call
+    JustOneLock.after_lock(path, f)
+
+    result
+  end
+end
+

data/lib/just_one_lock/blocking_locker.rb

@@ -0,0 +1,24 @@
+require 'timeout'
+
+class JustOneLock::BlockingLocker < JustOneLock::BaseLocker
+  DEFAULT_TIMEOUT = 1
+
+  attr_accessor :timeout
+
+  def initialize(timeout: DEFAULT_TIMEOUT)
+    @timeout = timeout
+  end
+
+  def lock(lock_path, &block)
+    result = nil
+
+    File.open(lock_path, File::RDWR|File::CREAT, 0644) do |f|
+      Timeout::timeout(@timeout, JustOneLock::AlreadyLocked) { f.flock(File::LOCK_EX) }
+
+      result = run(f, lock_path, &block)
+    end
+
+    result
+  end
+end
+

data/lib/just_one_lock/non_blocking_locker.rb

@@ -0,0 +1,16 @@
+class JustOneLock::NonBlockingLocker < JustOneLock::BaseLocker
+  def lock(lock_path, &block)
+    result = nil
+
+    File.open(lock_path, File::RDWR|File::CREAT, 0644) do |f|
+      if f.flock(File::LOCK_NB|File::LOCK_EX)
+        result = run(f, lock_path, &block)
+      else
+        fail JustOneLock::AlreadyLocked
+      end
+    end
+
+    result
+  end
+end
+

data/lib/just_one_lock/version.rb

@@ -1,3 +1,3 @@
 module JustOneLock
-  VERSION = '0.0.9'
+  VERSION = '0.1.0'
 end

data/lib/just_one_lock/world.rb

@@ -0,0 +1,42 @@
+class JustOneLock::World
+  attr_accessor :output, :directory, :delete_files
+
+  def initialize
+    @files = {}
+    @output = $stdout
+    @directory = '/tmp'
+    @delete_files = true
+  end
+
+  def delete_unlocked_files
+    paths_to_delete = []
+
+    @files.each do |path, f|
+      if File.exists?(path) && f.closed?
+        paths_to_delete << path
+      end
+    end
+
+    paths_to_delete.each do |path|
+      File.delete(path)
+      @files.delete(path)
+    end
+  end
+
+  def before_lock(name, file)
+    @files[name] = file
+  end
+
+  def after_lock(name, file)
+    delete_unlocked_files if delete_files
+  end
+
+  def lock_paths
+    @files.keys
+  end
+
+  def puts(*args)
+    output.puts(*args)
+  end
+
+end

data/lib/just_one_lock.rb

@@ -1,55 +1,35 @@
 require 'just_one_lock/version'
-require 'just_one_lock/blocking'
-require 'just_one_lock/non_blocking'
+require 'just_one_lock/world'
+require 'just_one_lock/base_locker'
+require 'just_one_lock/blocking_locker'
+require 'just_one_lock/non_blocking_locker'
+require 'forwardable'
 
 module JustOneLock
   class AlreadyLocked < StandardError; end
 
-  class NullStream
-    class << self
-      def puts(str); end
-    end
-  end
-
-  @files = {}
-
-  def self.delete_unlocked_files
-    paths_to_delete = []
-
-    @files.each do |path, f|
-      if File.exists?(path) && f.closed?
-        paths_to_delete << path
-      end
-    end
-
-    paths_to_delete.each do |path|
-      File.delete(path)
-      @files.delete(path)
-    end
+  class << self
+    extend ::Forwardable
+    def_delegators :world, :before_lock, :after_lock, :delete_unlocked_files
   end
 
-  def self.lock_paths
-    @files.keys
+  def self.world
+    @world ||= JustOneLock::World.new
   end
 
-  def self.already_locked(output, scope)
-    msg = "Another process <#{scope}> already is running"
-    output.puts msg
-    raise JustOneLock::AlreadyLocked, msg
-  end
-
-  private
-
-  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
+  def self.prevent_multiple_executions(
+    locker,
+    scope,
+    &block
+  )
+    scope_name = scope.gsub(':', '_')
+    lock_path = File.join(world.directory, scope_name + '.lock')
+
+    begin
+      return locker.lock(lock_path, &block)
+    rescue JustOneLock::AlreadyLocked => e
+      locker.already_locked(scope)
+    end
   end
 end
+

data/spec/just_one_lock/blocking_spec.rb

@@ -3,38 +3,10 @@ require 'tempfile'
 require 'timeout'
 require 'just_one_lock/locking_object'
 
-describe JustOneLock::Blocking do
+describe JustOneLock::BlockingLocker do
+  let(:locker) { JustOneLock::BlockingLocker.new }
   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
@@ -42,7 +14,7 @@ describe JustOneLock::Blocking do
 
       parallel_forks(6) do
         number = File.read('/tmp/number.txt').to_i
-        sleep(JustOneLock::Blocking::DEFAULT_TIMEOUT / 100)
+        sleep(0.1)
         write('/tmp/number.txt', (number + 7).to_s)
       end
 
@@ -71,7 +43,7 @@ describe JustOneLock::Blocking do
 
     parallel(2) do
       value = answer
-      sleep(JustOneLock::Blocking::DEFAULT_TIMEOUT / 2)
+      sleep(0.5)
       answer = value + 21
     end
 

data/spec/just_one_lock/locking_object.rb

@@ -6,7 +6,7 @@ shared_examples 'a locking object' do
       lockpath = File.join(lock_dir, 'sample.lock')
       answer = 0
 
-      JustOneLock::Blocking.filelock lockpath do
+      locker.lock lockpath do
         answer += 42
       end
 
@@ -19,7 +19,7 @@ shared_examples 'a locking object' do
       lockpath = File.join(lock_dir, 'sample.lock')
       answer = 0
 
-      answer = JustOneLock::Blocking.filelock lockpath do
+      answer = locker.lock lockpath do
         42
       end
 
@@ -40,13 +40,13 @@ shared_examples 'a locking object' do
     answer = 0
 
     begin
-      JustOneLock::Blocking.filelock(lockpath) do
+      locker.lock(lockpath) do
         raise '42'
       end
     rescue RuntimeError
     end
 
-    JustOneLock::Blocking.filelock(lockpath) do
+    locker.lock(lockpath) do
       answer += 42
     end
 
@@ -61,7 +61,7 @@ shared_examples 'a locking object' do
       locked = false
 
       Thread.new do
-        JustOneLock::Blocking.filelock lockpath do
+        locker.lock lockpath do
           locked = true
           sleep 20
         end
@@ -74,7 +74,7 @@ shared_examples 'a locking object' do
       end
 
       expect do
-        JustOneLock::Blocking.filelock lockpath, timeout: 0.001 do
+        locker.lock lockpath do
           answer = 0
         end
       end.to raise_error(JustOneLock::AlreadyLocked)
@@ -91,7 +91,7 @@ shared_examples 'a locking object' do
       dir, scope = dir_and_scope(lockpath)
 
       pid = fork {
-        JustOneLock::Blocking.prevent_multiple_executions(lock_dir, scope) do
+        JustOneLock::prevent_multiple_executions(locker, scope) do
           sleep 10
         end
       }
@@ -105,7 +105,7 @@ shared_examples 'a locking object' do
       answer = 0
 
       thread = Thread.new {
-        JustOneLock::Blocking.prevent_multiple_executions(dir, scope) do
+        JustOneLock::prevent_multiple_executions(locker, scope) do
           answer += 42
         end
       }
@@ -122,7 +122,7 @@ shared_examples 'a locking object' do
         lockpath = Pathname.new(File.join(lock_dir, 'sample.lock'))
 
         answer = 0
-        JustOneLock::Blocking.filelock lockpath do
+        locker.lock lockpath do
           answer += 42
         end
 
@@ -135,7 +135,7 @@ shared_examples 'a locking object' do
   it 'works for Tempfile' do
     answer = 0
 
-    JustOneLock::Blocking.filelock Tempfile.new(['sample', '.lock']) do
+    locker.lock Tempfile.new(['sample', '.lock']) do
       answer += 42
     end
 
@@ -146,7 +146,7 @@ shared_examples 'a locking object' do
   it 'creates file with exact path provided' do
     filename = "/tmp/awesome-lock-#{rand}.lock"
 
-    JustOneLock::Blocking.filelock filename, delete_files: false do
+    locker.lock filename do
     end
 
     expect(File.exist?(filename)).to eq(true)

data/spec/just_one_lock/non_blocking_spec.rb

@@ -3,36 +3,8 @@ require 'tempfile'
 require 'timeout'
 require 'just_one_lock/locking_object'
 
-describe JustOneLock::NonBlocking do
+describe JustOneLock::NonBlockingLocker do
+  let(:locker) { JustOneLock::NonBlockingLocker.new }
   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::NonBlocking.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::NonBlocking.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/spec_helper.rb

@@ -1,7 +1,3 @@
-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) }
@@ -14,3 +10,37 @@ def dir_and_scope(lockpath)
   dir = path_segments.join('/')
   [dir, scope]
 end
+
+def parallel(n = 2, lockpath: Tempfile.new(['sample', '.lock']).path, &block)
+  Timeout::timeout(5) do
+    dir, scope = dir_and_scope(lockpath)
+    JustOneLock.world.directory = dir
+
+    (1..n).map do
+      Thread.new do
+        JustOneLock::prevent_multiple_executions(locker, scope, &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)
+    JustOneLock.world.directory = dir
+
+    (1..n).map do
+      fork {
+        JustOneLock::prevent_multiple_executions(locker, scope, &block)
+      }
+    end.map do |pid|
+      Process.waitpid(pid)
+    end
+  end
+
+  JustOneLock.delete_unlocked_files
+end
+
+JustOneLock.world.delete_files = false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: just_one_lock
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Yury Kotov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-15 00:00:00.000000000 Z
+date: 2014-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,9 +84,11 @@ files:
 - bin/just_one_lock
 - 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/base_locker.rb
+- lib/just_one_lock/blocking_locker.rb
+- lib/just_one_lock/non_blocking_locker.rb
 - lib/just_one_lock/version.rb
+- lib/just_one_lock/world.rb
 - spec/just_one_lock/blocking_spec.rb
 - spec/just_one_lock/locking_object.rb
 - spec/just_one_lock/non_blocking_spec.rb

data/lib/just_one_lock/blocking.rb

@@ -1,41 +0,0 @@
-require 'timeout'
-
-module JustOneLock::Blocking
-  DEFAULT_TIMEOUT = 1
-
-  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::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::AlreadyLocked => e
-      JustOneLock.already_locked(output, scope)
-    end
-  end
-end
-

data/lib/just_one_lock/non_blocking.rb

@@ -1,40 +0,0 @@
-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)
-      else
-        fail JustOneLock::AlreadyLocked
-      end
-    end
-
-    JustOneLock.delete_unlocked_files if delete_files
-    result
-  end
-
-
-  def self.prevent_multiple_executions(
-    lock_dir,
-    scope,
-    output: JustOneLock::NullStream,
-    delete_files: true,
-    &block
-  )
-    scope_name = scope.gsub(':', '_')
-    lock_path = File.join(lock_dir, scope_name + '.lock')
-
-    begin
-      return filelock(lock_path, delete_files: delete_files, &block)
-    rescue JustOneLock::AlreadyLocked => e
-      JustOneLock.already_locked(output, scope)
-    end
-  end
-end
-
-