with_lock 0.0.4.alpha

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTIxODdiOTM5NjRiZGEwMWRmYTE3NDJiMDEyMmQ5N2NiZWNhNTRiOQ==
+  data.tar.gz: !binary |-
+    NDNkNjI2MDUxMmZhYmE3OWNmZThiOTI5NzMzNjgzOTFlOTU0NTNlMQ==
+SHA512:
+  metadata.gz: !binary |-
+    MDNhYTE5YTI3ZTE3ZWJhMTY4ODNlNWExNjI4YTQ2Y2ExNjM3NjVkM2M4OTk1
+    ODlhMmM4MTNlNzEyOGZkZjVjMzIyODcwZWNjMDc5NGRjM2MxOTlmYTFmZGE0
+    ZTBjNmFlOGRjZDgwZGU0MjA2NDNhZTJjZTc2MThjN2FkM2FjZWY=
+  data.tar.gz: !binary |-
+    NzQzMWRhZTE5YjFlZDkyODFhY2FmNzRlODdkYzcxMmQyZWFhMWI3YjgzYWI3
+    NThiMjNlNDExYjkzYjZmM2FiMzAyZTc0Y2M1ZjE2ZWNjMWU5NDQ5NzFmNjU3
+    OTFmMWY3NTZiYmRmOTgwYmFkNGFmMmU3N2Y4MzFhYzRmYmExYzY=

data/.gitignore

@@ -0,0 +1,8 @@
+# no tmp files
+/tmp
+
+# no log files
+/log
+
+# no OS files
+*.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    with_lock (0.0.4.alpha)
+      daemons
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    daemons (1.1.9)
+    diff-lcs (1.1.3)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec
+  with_lock!

data/README.md

@@ -0,0 +1,45 @@
+# WithLock
+
+Provides a DRb service to provide locking across a distributed ruby application.
+
+## Installation
+
+Add to your Gemfile and run the `bundle` command to install it.
+
+```ruby
+gem "with_lock", git: 'https://github.com/chrisboy333/with_lock.git'
+```
+
+**Tested under Ruby 1.9.3.**
+
+Add script and config files to your project(from console):
+```ruby
+WithLock.setup
+```
+In the configuration file you can change some settings if you like ... it defaults to using the following... where 'scope' is the application directory name with rails environment appended(if present):
+  url: druby://loclahost:9999
+  scope: <%= File.basename(File.expand_path('.')) %><%= ":#{Rails.env}" if defined?(Rails) %>
+  directory: tmp  
+  
+The scope is used to let different applications use the same drb server ... or different parts of an app acquire the same named locks(not that I think this latter is a great idea) ...
+
+Start/Stop the service from ruby
+```ruby
+WithLock::Server.start_service
+WithLock::Server.stop_service
+```
+Start/Stop service from 
+
+## Usage
+A "with_lock()" function is provided globally to wrap with_lock sections of code.
+ 
+```ruby
+with_lock('lock_name') do
+  puts "This is something only I can do right now, provided others are using the locks!"
+end 
+```
+## Development
+
+Questions or problems? Please post them on the [issue tracker](https://github.com/chrisboy333/with_lock/issues). You can contribute changes by forking the project and submitting a pull request. You can ensure the tests passing by running `bundle` and `rake`.
+
+This gem is created by Christopher Hauboldt and is under the MIT License.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+desc 'Run the specs'
+RSpec::Core::RakeTask.new do |r|
+  r.verbose = false
+end
+
+task :default => :spec

data/config/with_lock.local.yml

@@ -0,0 +1,3 @@
+url: druby://localhost:9999
+scope: <%= File.basename(File.expand_path('.')) %><%= ":#{Rails.env}" if defined?(Rails) %>
+directory: 'tmp'

data/config/with_lock.yml

@@ -0,0 +1,3 @@
+url: druby://localhost:9999
+scope: <%= File.basename(File.expand_path('.')) %><%= ":#{Rails.env}" if defined?(Rails) %>
+directory: 'tmp'

data/lib/with_lock.rb

@@ -0,0 +1,89 @@
+require "with_lock/version"
+require 'erb'
+require 'yaml'
+require 'fileutils'
+require 'logger'
+
+module WithLock
+  class LockException < Exception
+  end
+  
+  def self.setup
+    gem_dir = File.expand_path(File.join('..','..'),__FILE__)
+    app_dir = File.expand_path('.')
+    FileUtils.cp(File.join(gem_dir,'config','with_lock.yml'),File.join(app_dir,'config','with_lock.yml'))
+    FileUtils.cp(File.join(gem_dir,'script','with_lock'),File.join(app_dir,'script','with_lock'))
+    FileUtils.chmod(0755, File.join(app_dir,'script','with_lock'))
+    true
+  end
+
+  module Public
+    def with_lock(name,timeout=5,&block)
+      WithLock::Client.with_lock(name,timeout) do
+        yield
+      end
+    end
+  end
+  
+  module Common
+    def logger
+      return @@logger if defined?(@@logger) && !@@logger.nil?
+      @@logger = nil
+      @@logger = Rails.logger if defined?(Rails)
+      FileUtils.mkdir_p('log') if @@logger.nil?
+      @@logger ||= Logger.new(File.join('log','with_lock.log'))
+    end
+    
+    def url
+      settings['url']
+    end
+    
+    def pidfile
+      File.join('tmp','pids','with_lock.pid')
+    end
+    
+    def pid
+      File.read(pidfile).strip
+    rescue => e
+      nil
+    end
+    
+    def running?(pid)
+      `ps -p#{pid} | wc -l`.to_i == 2
+    end
+    
+    def settings_filename
+      File.join('config','with_lock.yml')
+    end
+    
+    def local_settings_filename
+      File.join('config','with_lock.local.yml')
+    end
+    
+    def settings
+      return @@settings if defined? @@settings
+      @@settings = default_settings
+      @@settings = @@settings.merge!(load_settings(settings_filename)||{}) if File.exists?(settings_filename)
+      @@settings.merge!(load_settings(local_settings_filename)||{}) if File.exists?(local_settings_filename)
+      @@settings
+    end
+    
+    def default_settings
+      {
+        'directory' => File.join('tmp'),
+        'url' => "druby://localhost:9999",
+        'scope' => "#{File.basename(File.expand_path('.'))}#{":#{Rails.env}" if defined?(Rails)}"
+      }
+    end
+    
+    def load_settings(filename)
+      YAML.load(ERB.new(File.read(filename)).result)
+    end
+  end
+end
+
+WithLock::Public.respond_to?(:with_lock)
+
+require 'with_lock/server'
+require 'with_lock/client'
+Object.send :include, WithLock::Public

data/lib/with_lock/client.rb

@@ -0,0 +1,76 @@
+class WithLock::Client
+  extend WithLock::Common
+  @@locker = nil
+  
+  def self.scoped_name(name)
+    "#{scope}-#{name}"
+  end
+  
+  def self.identity
+    "#{`hostname`.strip}|#{$$}"
+  end
+  
+  def self.get(name,timeout=5)
+    locker.get(identity,scoped_name(name),timeout)
+  end
+  
+  def self.release(name)
+    locker.release(identity,scoped_name(name))
+  end
+  
+  def self.mine?(name)
+    locker.mine?(identity,scoped_name(name))
+  end
+  
+  def self.with_lock(name, timeout=5, &block)
+    begin
+      locked = mine?(name) && increment(name)
+      locked ||= get(name,timeout) || raise(WithLock::LockException.new("Failed to obtain lock #{name} in #{timeout} seconds."))
+      yield
+    ensure
+      if locker_available?
+        decrement(name).to_i > 0 || release(name) || logger.debug("Warning: lock #{name} not released!")
+      end
+    end
+  end
+  
+  def self.locker_available?
+    locker.url
+    true
+  rescue DRb::DRbConnError => e
+    false
+  end
+  
+  def self.increment(name)
+    locker.increment(identity,scoped_name(name))
+  end
+
+  def self.decrement(name)
+    locker.decrement(identity,scoped_name(name))
+  end
+  
+  def self.scope
+    @@scope ||= Rails.env if defined? Rails
+    @@scope ||= File.expand_path('.').split(File::SEPARATOR).last
+  end
+  
+  def self.reconnect!
+    DRb.stop_service
+    @@uri = DRb.start_service
+    @@locker = DRbObject.new_with_uri(url)
+  end
+  
+  def self.locker
+    return @@locker if (@@locker.url rescue false)
+    @@locker = nil
+    tries = 3
+    while @@locker.nil? && tries > 0 do
+      sleep 0.2 if tries < 3
+      tries -= 1
+      reconnect!
+      @@locker = nil unless (@@locker.url rescue false)
+    end
+    raise WithLock::LockException.new("Couldn't connect to locker.") if @@locker.nil?
+    @@locker
+  end
+end

data/lib/with_lock/server.rb

@@ -0,0 +1,119 @@
+require 'drb'
+require 'daemons'
+
+class WithLock::Server
+  extend WithLock::Common
+  
+  def self.mutex
+    @@mutex ||= Mutex.new
+  end
+  
+  def self.owner_uri?(name)
+    locks[name][:owner]
+  rescue => e
+    ''
+  end
+  
+  def self.owner_pid(name)
+    locks[name][:pid]
+  rescue => e
+    ''
+  end
+  
+  def self.count(name)
+    locks[name][:count]
+  rescue => e
+    0
+  end
+  
+  def self.locked?(name)
+    !locks[name].nil?# && owner_active?(name)
+  end
+  
+  def self.mine?(owner,name)
+    locked?(name) && locks[name][:owner].eql?(owner)
+  end
+  
+  def self.get(owner,name,timeout=5)
+    endtime = Time.now.to_f + timeout.to_f
+    owner_uri, owner_pid = owner.split('|')
+    while !mine?(owner,name)  && (Time.now.to_f < endtime)
+      mutex.synchronize do
+        if !locked?(name)
+          locks[name] = {owner: owner, count: 1}
+        end
+      end
+      sleep 0.01 unless mine?(owner,name)
+    end
+    mine?(owner,name)
+  end
+  
+  def self.release(owner,name)
+    if mine?(owner,name)
+      locks.delete(name)
+      true
+    else
+      false
+    end
+  end
+  
+  def self.increment(owner,name)
+    if mine?(owner,name)
+      locks[name][:count] += 1
+    end
+    count(name)
+  end
+
+  def self.decrement(owner,name)
+    if mine?(owner,name)
+      locks[name][:count] -= 1
+    end
+    count(name)
+  end
+    
+  def self.locks
+    @@locks ||= {}
+  end
+  
+  def self.write_url(url)
+    File.open(File.join(settings['directory'],'with_lock'),'w'){|file| file.write(url)}
+  end
+  
+  def self.started?
+    pid.to_i > 0 && running?(pid)
+  end
+  
+  def self.daemon_settings
+    {
+       :multiple   => false,
+       :ontop      => false,
+       :backtrace  => true,
+       :log_output => true,
+       :monitor    => false,
+       :dir_mode   => :normal,
+       :dir        => 'tmp/pids'
+     }
+  end
+  
+  def self.start_service
+    return if started?
+    FileUtils.rm(pidfile) if File.exists?(pidfile)
+    options = daemon_settings.merge(:ARGV => ['start'])
+    Daemons.run_proc('with_lock', options) do 
+      DRb.start_service(WithLock::Server::url,WithLock::Server)
+      DRb.thread.join
+    end
+  end
+  
+  def self.run_service
+    return if started?
+    DRb.start_service(WithLock::Server::url,WithLock::Server)
+    DRb.thread.join
+  end
+  
+  def self.stop_service
+    return unless started?
+    `kill #{pid}`
+    FileUtils.rm_f(pidfile)
+  end
+end

data/lib/with_lock/version.rb

@@ -0,0 +1,4 @@
+module WithLock
+  VERSION = "0.0.4.alpha"
+end
+

data/script/with_lock

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path(File.join('..','..','lib'), __FILE__)
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+FileUtils.mkdir_p('tmp/pids') unless File.exists?('tmp/pids')
+
+require 'with_lock'
+if ARGV.include?('start')
+  begin
+    locker = WithLock::Client.locker
+  rescue WithLock::LockException => e
+    puts "Starting WithLock on #{WithLock::Server::url}!"
+    WithLock::Server::start_service
+    locker = WithLock::Client.locker
+  end
+  puts "Clearing WithLock locks!"
+  locker = WithLock::Client.locker
+  locker.locks.each_pair do |lock,data|
+    pid = data[:owner].split('|').last
+    if locker.running?(pid) || !data[:owner].include?(`hostname`.strip)
+      puts "Running - pid"
+    else
+      puts "Not Running - pid"
+      locker.release(data[:owner],lock)
+    end
+  end
+elsif ARGV.include?('stop')
+  puts "Stopping WithLock!"
+  WithLock::Server::stop_service
+elsif ARGV.include?('run')
+  puts "Running WithLock!"
+  WithLock::Server::run_service
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$:.unshift(File.join(File.dirname(__FILE__),'..','lib'))
+require 'with_lock'

data/spec/support/echo_pid.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo $$

data/spec/support/get_lock.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path(File.join('..','..','lib'), __FILE__)
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require 'with_lock'
+include WithLock::Public
+
+begin
+  with_lock(ARGV[0],ARGV[1].to_f||0.5) do
+    sleep ARGV[2].to_f
+    Kernel.exit! if ARGV[3].eql?('kernel_exit')
+    exit(0) if ARGV[2].eql?('exit')
+  end
+rescue WithLock::LockException => e
+  puts exit(1)
+end

data/spec/with_lock_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+require File.expand_path(File.join('..','spec','spec_helper'), File.dirname(__FILE__))
+
+describe WithLock do
+  describe "#settings" do
+    it "should have default settings" do
+      WithLock::Client::settings.should == {
+        'url' => 'druby://localhost:9999',
+        'directory' => 'tmp',
+        'scope' => 'with_lock'
+      }
+    end
+  end
+  
+  describe "#url" do
+    it "returns the druby url from settings" do
+      WithLock::Client::settings['url'].should == WithLock::Client::url
+    end
+  end
+  
+  describe "#running(pid)" do
+    it "should report if given process id represents a running pid" do
+      WithLock::Server::running?($$).should be_true
+    end
+    it "should report if given process id doesn't represent a running pid" do
+      pid = `spec/support/echo_pid.sh`.to_s.strip
+      sleep 0.2
+      WithLock::Server::running?(pid).should be_false
+    end
+  end
+  
+  describe "#with_lock" do 
+    it "should raise an exception if with_lock server not started" do
+      WithLock::Server.stop_service
+      started_trying = Time.now
+      while WithLock::Server.started? do
+        sleep 0.2
+        raise Exception.new("Couldn't stop server!") unless (Time.now - 3.seconds) > started_trying
+      end
+      error_message = ''
+      begin
+        with_lock('my_lock') do
+          "I should not get here!".should be_nil
+        end
+      rescue WithLock::LockException => e
+        e.message.should == "Couldn't connect to locker."
+      end
+    end
+    describe "when the server is running" do
+      before(:all) do
+        `script/with_lock start`
+        started_trying = Time.now
+        while !WithLock::Server.started? do
+          sleep 0.2
+          raise Exception.new("Couldn't start server!") unless (Time.now - 3.seconds) > started_trying
+        end
+        @locker = WithLock::Client.locker
+      end
+      after(:all) do
+        `script/with_lock stop`
+        while WithLock::Server.started? do
+          sleep 0.1
+        end
+      end
+      it "should grab the named lock if its not locked" do
+        with_lock('name') do 
+          WithLock::Client.mine?('name').should be_true
+        end
+      end
+      it "should not allow another process to grab the same named lock" do
+        system("spec/support/get_lock.rb name 0.5 10 &")
+        sleep 1
+        expect {
+          with_lock('name',0.5) do
+          end
+        }.to raise_exception(WithLock::LockException)
+      end
+      
+      it "should have a counter of 1 when it first grabs the lock" do
+        with_lock('blarg') do
+          @locker.count(WithLock::Client.scoped_name('blarg')).should == 1
+        end
+      end
+        
+      it "should allow the same process to grab the same lock and increment its counter" do
+        with_lock('blarg') do
+          with_lock('blarg') do
+            @locker.count(WithLock::Client.scoped_name('blarg')).should == 2
+          end
+        end
+      end
+      
+      it "should decrement a lock's counter when it ends the block" do
+        with_lock('blarg') do
+          with_lock('blarg') do
+          end
+          @locker.count(WithLock::Client.scoped_name('blarg')).should == 1
+        end
+      end
+      
+      it "should release the lock when the block ends" do
+        with_lock('blarg') do
+        end
+        @locker.locks[WithLock::Client.scoped_name('blarg')].should be_nil
+      end
+      
+      it "should release the lock if an exception closes the block" do
+        begin
+          with_lock('blarg') do
+            raise "Blarg!!"
+          end
+        rescue => e
+        end
+        @locker.locks[WithLock::Client.scoped_name('blarg')].should be_nil
+      end
+      
+      it "should release the lock on a clean exit" do
+        `spec/support/get_lock.rb blarg 0.3 exit`
+        sleep 0.2
+        @locker.locks[WithLock::Client.scoped_name('blarg')].should be_nil
+      end
+      
+      it "should release the lock on an immediate exit" do
+        `spec/support/get_lock.rb blarg 0.3 kernel_exit`
+        sleep 0.2
+        @locker.locks[WithLock::Client.scoped_name('blarg')].should be_nil
+      end
+    end
+  end
+end

data/with_lock.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'with_lock/version'
+
+Gem::Specification.new do |s|
+  s.name        = "with_lock"
+  s.version     = WithLock::VERSION
+  s.authors     = ["Christopher Louis Hauboldt"]
+  s.email       = ["chris@hauboldt.us"]
+  s.homepage    = "https://github.com/chrisboy333/with_lock"
+  s.summary     = %q{Implements named mutexes for ruby applications.}
+  s.description = %q{Implements named mutexes for ruby applications by creating a resource server to query for locks.}
+
+  s.rubyforge_project = "with_lock"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_dependency "daemons"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: with_lock
+version: !ruby/object:Gem::Version
+  version: 0.0.4.alpha
+platform: ruby
+authors:
+- Christopher Louis Hauboldt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-13 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Implements named mutexes for ruby applications by creating a resource
+  server to query for locks.
+email:
+- chris@hauboldt.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- config/with_lock.local.yml
+- config/with_lock.yml
+- lib/with_lock.rb
+- lib/with_lock/client.rb
+- lib/with_lock/server.rb
+- lib/with_lock/version.rb
+- script/with_lock
+- spec/spec_helper.rb
+- spec/support/echo_pid.sh
+- spec/support/get_lock.rb
+- spec/with_lock_spec.rb
+- with_lock.gemspec
+homepage: https://github.com/chrisboy333/with_lock
+licenses: []
+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: 1.3.1
+requirements: []
+rubyforge_project: with_lock
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Implements named mutexes for ruby applications.
+test_files:
+- spec/spec_helper.rb
+- spec/support/echo_pid.sh
+- spec/support/get_lock.rb
+- spec/with_lock_spec.rb