filelock 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ca5c3766ead1d38142a6a07fff24bb2b84eb1bf8
+  data.tar.gz: 7fa07b19de6de7a852412b07a3425d6992a0fbb2
+SHA512:
+  metadata.gz: cea750b7cf162bb5c7924a442a29acb02cb0ea7a2cd26baa29e3c3227e55a238bcf8ce6cc01bfca1d611f6b43aaa66481a6efeb4b00afea9e5389d62787997d7
+  data.tar.gz: 78f0673ea1fbadc2658c3e455b7d5eadb1eb5b6522313e6944bafc4314ec4d45fbcd5f2633cdefe1a36552d402c7fb06d1dc2a936ed7b4db257ccf22283e5aca

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+script: bundle exec rspec
+rvm:
+  - "1.8.7"
+  - "1.9.3"
+  - "1.9.2"
+  - "2.0.0"
+  - jruby-19mode
+  - jruby-18mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in filelock.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adam Stankiewicz
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,56 @@
+# Filelock [![Build Status][travis-img-url]][travis-url]
+
+[travis-img-url]: https://travis-ci.org/sheerun/filelock.png
+[travis-url]: https://travis-ci-org/sheerun/filelock
+
+Heavily tested, but simple filelocking solution using [flock](http://linux.die.net/man/2/flock) command. It guarantees unlocking of files.
+
+It works for sure on MRI 1.8, 1.9, 2.0, JRuby in both 1.8 and 1.9 mode, and Rubinius.
+
+## Usage
+
+```ruby
+Filelock '/tmp/path/to/lock' do
+  # do blocking operation
+end
+```
+
+You can also pass the timeout for blocking operation (default is 60 seconds):
+
+```ruby
+Filelock '/tmp/path/to/lock', :timeout => 10 do
+  # do blocking operation
+end
+```
+
+Note that lock file directory must already exist, and lock file is not removed after unlock.
+
+## FAQ
+
+*Does it support NFS?*
+
+No. You can use more complex [lockfile](https://github.com/ahoward/lockfile) gem if you want to support NFS.
+
+*The code is so short. Why shouln't I just copy-paste it?*
+
+Because even such short code can have issues in future. File locking is very fragile operation. You may expect new releases of this gem fixing discovered bogus behavior (or introducing awesome features).
+
+You are encouraged to use it if you develop gem that uses flock command, and care about running it on different ruby versions and platforms. Each has its own quirks with regard to flock command.
+
+*How it's different from [lockfile](https://github.com/ahoward/lockfile) gem?*
+
+Lockfile is filelocking solution handling NFS filesystems, based on homemade locking solution. Filelock uses [flock](http://linux.die.net/man/2/flock) UNIX command to handle filelocking on very low level. Also lockfile allows you to specify retry timeout. In case of Ruby's flock command this is hard-cored to 0.1 seconds.
+
+*How it's different from [cleverua-lockfile](https://github.com/cleverua/lockfile) gem?*
+
+Cleverua removes lockfile after unlocking it. Thas has been proven fatal both in my tests and in [filelocking advices from the Internet](http://world.std.com/~swmcd/steven/tech/flock.html). You could try find a way to remove lock file without breaking Filelock tests. I will be glad to accept such pull-request.
+
+## Challenge
+
+Please try to break Filelock in some way (note it doesn't support NFS).
+
+If you show at least one failing test, I'll put your name below:
+
+## License
+
+Filelock is MIT-licensed. You are awesome.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/filelock.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filelock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "filelock"
+  spec.version       = Filelock::VERSION
+  spec.authors       = ["Adam Stankiewicz"]
+  spec.email         = ["sheerun@sher.pl"]
+  spec.description   = %q{Heavily tested yet simple filelocking solution using flock}
+  spec.summary       = %q{Heavily tested yet simple filelocking solution using flock}
+  spec.homepage      = "http://github.com/sheerun/filelock"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/filelock.rb

@@ -0,0 +1,21 @@
+require 'filelock/version'
+require 'timeout'
+require 'tempfile'
+
+if RUBY_PLATFORM == "java"
+  def Filelock(lockname, options = {}, &block)
+    lockname = lockname.path if lockname.is_a?(Tempfile)
+    File.open(lockname, File::RDWR|File::CREAT, 0644) do |file|
+      Thread.pass until file.flock(File::LOCK_EX)
+      Timeout::timeout(options.fetch(:timeout, 60)) { yield }
+    end
+  end
+else
+  def Filelock(lockname, options = {}, &block)
+    lockname = lockname.path if lockname.is_a?(Tempfile)
+    File.open(lockname, File::RDWR|File::CREAT, 0644) do |file|
+      file.flock(File::LOCK_EX)
+      Timeout::timeout(options.fetch(:timeout, 60)) { yield }
+    end
+  end
+end

data/lib/filelock/version.rb

@@ -0,0 +1,3 @@
+module Filelock
+  VERSION = "1.0.3"
+end

data/spec/filelock_spec.rb

@@ -0,0 +1,232 @@
+require 'filelock'
+require 'tempfile'
+require 'timeout'
+
+describe Filelock 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 parallel(n = 2, templock = nil, &block)
+    Timeout::timeout(5) do
+      templock ||= Tempfile.new(['sample', '.lock'])
+
+      (1..n).map do
+        Thread.new do
+          Filelock(templock, &block)
+        end
+      end.map(&:join)
+    end
+  end
+
+  def parallel_forks(n = 2, templock = nil, &block)
+    Timeout::timeout(5) do
+      templock ||= Tempfile.new(['sample', '.lock'])
+
+      (1..n).map do
+        fork {
+          Filelock(templock, &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
+
+      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 = 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 0.1
+      answer = value + 21
+    end
+
+    expect(answer).to eq(42)
+  end
+
+  it 'handels high amount of concurrent tasks' do
+    answer = 0
+
+    parallel(100) do
+      value = answer
+      sleep 0.001
+      answer = value + 1
+    end
+
+    expect(answer).to eq(100)
+  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
+    end
+  end
+
+  it 'runs in parallel without race condition' do
+    Dir.mktmpdir do |dir|
+      lockpath = File.join(dir, 'sample.lock')
+
+      answer = 0
+
+      begin
+        Filelock(lockpath) do
+          raise '42'
+        end
+      rescue RuntimeError
+      end
+
+      Filelock(lockpath) do
+        answer += 42
+      end
+
+      expect(answer).to eq(42)
+    end
+  end
+
+  it 'times out after specified number of seconds' do
+    Dir.mktmpdir do |dir|
+      lockpath = File.join(dir, 'sample.lock')
+
+      answer = 42
+
+      begin
+        Filelock lockpath, :timeout => 1 do
+          sleep 2
+          answer = 0
+        end
+      rescue Timeout::Error
+      end
+
+      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 0.3
+        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')
+
+      parallel_forks(100) 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)
+    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 {
+            Filelock lockpath do
+              sleep 10
+            end
+          }
+
+          sleep 0.5
+
+          answer = 0
+
+          thread = Thread.new {
+            Filelock lockpath do
+              answer += 42
+            end
+          }
+
+          sleep 0.5
+
+          expect(answer).to eq(0)
+          Process.kill(9, pid)
+          thread.join
+
+          expect(answer).to eq(42)
+        end
+      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
+        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
+
+    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"
+
+    Filelock filename do
+    end
+
+    expect(File.exist?(filename)).to eq(true)
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: filelock
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+platform: ruby
+authors:
+- Adam Stankiewicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: Heavily tested yet simple filelocking solution using flock
+email:
+- sheerun@sher.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- filelock.gemspec
+- lib/filelock.rb
+- lib/filelock/version.rb
+- spec/filelock_spec.rb
+homepage: http://github.com/sheerun/filelock
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Heavily tested yet simple filelocking solution using flock
+test_files:
+- spec/filelock_spec.rb
+has_rdoc: