lock_method 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+rdoc/*
+secret.sh

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,46 @@
+= lock_method
+
+It's like <tt>alias_method</tt>, but it's <tt>lock_method</tt>!
+
+== Example
+
+    require 'lock_method'
+    class Blog
+      # [...]
+      def get_latest_entries
+        sleep 5
+      end
+      # [...]
+      lock_method :get_latest_entries
+    end
+
+Then you can do
+
+    my_blog.get_latest_entries => it will start...
+    my_blog.get_latest_entries => this will raise LockMethod::Locked if you try to run it before the other call finishes
+
+Just in case, you can clear them
+
+    my_blog.clear_lock :get_latest_entries
+
+== Configuration (and supported cache clients)
+
+The default is to use filesystem lockfiles, usually in <tt>/tmp/lock_method/*</tt>.
+
+If you want to share locks among various machines, you can use a Memcached or Redis client:
+
+    LockMethod.config.storage = Memcached.new '127.0.0.1:11211'
+
+or
+
+    LockMethod.config.storage = Redis.new
+
+or this might even work...
+
+    LockMethod.config.storage = Rails.cache
+
+See <tt>Config</tt> for the full list of supported caches.
+
+== Copyright
+
+Copyright 2011 Seamus Abshere

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lock_method #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/lock_method.rb

@@ -0,0 +1,63 @@
+require 'lock_method/version'
+# See the README.rdoc for more info!
+module LockMethod
+  autoload :Config, 'lock_method/config'
+  autoload :Storage, 'lock_method/storage'
+  autoload :Lock, 'lock_method/lock'
+
+  # This is what gets raised when you try to run a locked method.
+  class Locked < ::StandardError
+  end
+
+  def self.config #:nodoc:
+    Config.instance
+  end
+  
+  def self.storage #:nodoc:
+    Storage.instance
+  end
+    
+  # All Objects, including instances and Classes, get the <tt>#clear_lock</tt> method.
+  module InstanceMethods
+    # Clear the lock for a particular method.
+    #
+    # Example:
+    #     my_blog.clear_lock :get_latest_entries
+    def clear_lock(method_id)
+      lock = ::LockMethod::Lock.new :obj => self, :method_id => method_id
+      lock.delete
+    end
+  end
+
+  # All Classes (but not instances), get the <tt>.lock_method</tt> method.
+  module ClassMethods
+    # Lock a method. TTL in seconds, defaults to whatever's in LockMethod.config.default_ttl
+    #
+    # Note 2: Check out LockMethod.config.default_ttl... the default is 24 hours!
+    #
+    # Example:
+    #     class Blog
+    #       # [...]
+    #       def get_latest_entries
+    #         sleep 5
+    #       end
+    #       # [...]
+    #       lock_method :get_latest_entries
+    #       # if you wanted a different ttl...
+    #       # lock_method :get_latest_entries, 800 #seconds
+    #     end
+    def lock_method(method_id, ttl = nil)
+      original_method_id = "_unlocked_#{method_id}"
+      alias_method original_method_id, method_id
+      define_method method_id do |*args|
+        lock = ::LockMethod::Lock.new :obj => self, :method_id => method_id, :original_method_id => original_method_id, :args => args, :ttl => ttl
+        lock.call_original_method
+      end
+    end
+  end
+end
+
+unless ::Object.method_defined? :lock_method
+  ::Object.send :include, ::LockMethod::InstanceMethods
+  ::Object.extend ::LockMethod::ClassMethods
+end

data/lib/lock_method/config.rb

@@ -0,0 +1,46 @@
+require 'singleton'
+module LockMethod
+  # Here's where you set config options.
+  #
+  # Example:
+  #     LockMethod.config.storage = Memcached.new '127.0.0.1:11211'
+  #
+  # You'd probably put this in your Rails config/initializers, for example.
+  class Config
+    include ::Singleton
+    
+    # Storage for keeping lockfiles.
+    #
+    # Defaults to using the filesystem's temp dir.
+    #
+    # Supported memcached clients:
+    # * memcached[https://github.com/fauna/memcached] (either a Memcached or a Memcached::Rails)
+    # * dalli[https://github.com/mperham/dalli] (either a Dalli::Client or an ActiveSupport::Cache::DalliStore)
+    # * memcache-storage[https://github.com/mperham/memcache-storage] (MemCache, the one commonly used by Rails)
+    #
+    # Supported Redis clients:
+    # * redis[https://github.com/ezmobius/redis-rb] (NOTE: AUTOMATIC CACHE EXPIRATION NOT SUPPORTED)
+    #
+    # Example:
+    #     LockMethod.config.storage = Memcached.new '127.0.0.1:11211'
+    def storage=(storage)
+      @storage = storage
+    end
+
+    def storage #:nodoc:
+      @storage ||= Storage::DefaultStorageClient.new
+    end
+    
+    # TTL for method caches. Defaults to 24 hours.
+    #
+    # Example:
+    #     LockMethod.config.default_ttl = 120 # seconds
+    def default_ttl=(seconds)
+      @default_ttl = seconds
+    end
+    
+    def default_ttl #:nodoc:
+      @default_ttl || 86_400
+    end
+  end
+end

data/lib/lock_method/lock.rb

@@ -0,0 +1,116 @@
+module LockMethod
+  class Lock
+    class << self
+      def find(method_signature)
+        if hsh = Storage.instance.get(method_signature)
+          new hsh
+        end
+      end
+      def klass_name(obj)
+        obj.is_a?(::Class) ? obj.to_s : obj.class.to_s
+      end
+      def method_delimiter(obj)
+        obj.is_a?(::Class) ? '.' : '#'
+      end
+      def method_signature(obj, method_id)
+        [ klass_name(obj), method_id ].join method_delimiter(obj)
+      end
+      def process_alive?(pid)
+        ::Process.kill 0, pid
+      rescue ::Errno::ESRCH
+        false
+      end
+      def thread_alive?(thread_object_id)
+        if thr = ::Thread.list.detect { |t| t.object_id == thread_object_id }
+          thr.status == 'sleep' or thr.status == 'run'
+        end
+      end
+    end
+
+    def initialize(options = {})
+      options.each do |k, v|
+        instance_variable_set "@#{k}", v
+      end
+    end
+
+    attr_reader :obj
+    attr_reader :method_id
+    attr_reader :original_method_id
+    attr_reader :args
+        
+    def method_signature
+      @method_signature ||= Lock.method_signature(obj, method_id)
+    end
+    
+    def ttl
+      @ttl ||= Config.instance.default_ttl
+    end
+    
+    def pid
+      @pid ||= ::Process.pid
+    end
+    
+    def thread_object_id
+      @thread_object_id ||= ::Thread.current.object_id
+    end
+    
+    def expiry
+      @expiry ||= ::Time.now + ttl
+    end
+    
+    def delete
+      Storage.instance.delete method_signature
+    end
+    
+    def save
+      # make sure these are set
+      self.pid
+      self.thread_object_id
+      self.expiry
+      # --
+      Storage.instance.set method_signature, to_hash, ttl
+    end
+    
+    def to_hash
+      instance_variables.inject({}) do |memo, ivar_name|
+        memo[ivar_name.to_s.sub('@', '')] = instance_variable_get ivar_name
+        memo
+      end
+    end
+    
+    def locked?
+      if existing_lock = Lock.find(method_signature)
+        existing_lock.in_force?
+      end
+    end
+    
+    def in_force?
+      not expired? and process_and_thread_still_exist?
+    end
+    
+    def expired?
+      expiry.to_f < ::Time.now.to_f
+    end
+    
+    def process_and_thread_still_exist?
+      if pid == ::Process.pid
+        Lock.thread_alive? thread_object_id
+      else
+        Lock.process_alive? pid
+      end
+    end
+    
+    def call_original_method
+      if locked?
+        raise Locked
+      else
+        begin
+          save
+          obj.send original_method_id, *args
+        ensure
+          delete
+        end
+      end
+    end
+  end
+end

data/lib/lock_method/storage.rb

@@ -0,0 +1,60 @@
+require 'singleton'
+module LockMethod
+  # All storage requests go through a clearinghouse.
+  class Storage #:nodoc: all
+    autoload :DefaultStorageClient, 'lock_method/storage/default_storage_client'
+    
+    include ::Singleton
+    
+    def delete(k)
+      if defined?(::Memcached) and bare_storage.is_a?(::Memcached)
+        begin; bare_storage.delete(k); rescue ::Memcached::NotFound; nil; end
+      elsif defined?(::Redis) and bare_storage.is_a?(::Redis)
+        bare_storage.del k
+      else
+        bare_storage.delete k
+      end
+    end
+    
+    def flush
+      bare_storage.send %w{ flush flush_all clear flushdb }.detect { |c| bare_storage.respond_to? c }
+    end
+    
+    def get(k)
+      if defined?(::Memcached) and bare_storage.is_a?(::Memcached)
+        begin; bare_storage.get(k); rescue ::Memcached::NotFound; nil; end
+      elsif defined?(::Redis) and bare_storage.is_a?(::Redis)
+        if cached_v = bare_storage.get(k) and cached_v.is_a?(::String)
+          ::Marshal.load cached_v
+        end
+      elsif bare_storage.respond_to?(:get)
+        bare_storage.get k
+      elsif bare_storage.respond_to?(:read)
+        bare_storage.read k
+      else
+        raise "Don't know how to work with #{bare_storage.inspect}"
+      end
+    end
+        
+    def set(k, v, ttl)
+      ttl ||= ::LockMethod.config.default_ttl
+      if defined?(::Redis) and bare_storage.is_a?(::Redis)
+        bare_storage.setex k, ttl, ::Marshal.dump(v)
+      elsif bare_storage.respond_to?(:set)
+        bare_storage.set k, v, ttl
+      elsif bare_storage.respond_to?(:write)
+        if ttl == 0
+          bare_storage.write k, v # never expire
+        else
+          bare_storage.write k, v, :expires_in => ttl
+        end
+      else
+        raise "Don't know how to work with #{bare_storage.inspect}"
+      end
+    end
+    
+    def bare_storage
+      Config.instance.storage
+    end
+  end
+end

data/lib/lock_method/storage/default_storage_client.rb

@@ -0,0 +1,47 @@
+require 'tmpdir'
+require 'fileutils'
+require 'thread'
+module LockMethod
+  class Storage
+    class DefaultStorageClient
+      def get(k)
+        return unless ::File.exist? path(k)
+        ::Marshal.load ::File.read(path(k))
+      rescue ::Errno::ENOENT
+      end
+    
+      def set(k, v, ttl)
+        semaphore.synchronize do
+          ::File.open(path(k), ::File::RDWR|::File::CREAT) do |f|
+            f.flock ::File::LOCK_EX
+            f.write ::Marshal.dump(v)
+          end
+        end
+      end
+    
+      def delete(k)
+        ::FileUtils.rm_f path(k)
+      end
+    
+      def flush
+        ::FileUtils.rm_rf dir
+      end
+    
+      private
+    
+      def semaphore
+        @semaphore ||= ::Mutex.new
+      end
+    
+      def path(k)
+        ::File.join dir, k
+      end
+    
+      def dir
+        dir = ::File.expand_path(::File.join(::Dir.tmpdir, 'lock_method'))
+        ::FileUtils.mkdir_p dir unless ::File.directory? dir
+        dir
+      end
+    end
+  end
+end

data/lib/lock_method/version.rb

@@ -0,0 +1,3 @@
+module LockMethod
+  VERSION = "0.0.1"
+end

data/lock_method.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lock_method/version"
+
+Gem::Specification.new do |s|
+  s.name        = "lock_method"
+  s.version     = LockMethod::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Seamus Abshere"]
+  s.email       = ["seamus@abshere.net"]
+  s.homepage    = "https://github.com/seamusabshere/lock_method"
+  s.summary     = %q{Lets you lock methods (to memcached, redis, etc.) as though you had a lockfile for each one}
+  s.description = %q{Like alias_method, but it's lock_method!}
+
+  s.rubyforge_project = "lock_method"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'memcached'
+  s.add_development_dependency 'redis'
+  if RUBY_VERSION >= '1.9'
+    s.add_development_dependency 'ruby-debug19'
+  else
+    s.add_development_dependency 'ruby-debug'
+  end
+end

data/test/helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'test/unit'
+require 'ruby-debug'
+require 'shared_tests'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'lock_method'
+
+class Blog1
+  attr_reader :name
+  attr_reader :url
+  def initialize(name, url)
+    @name = name
+    @url = url
+  end
+  def get_latest_entries
+    sleep 8
+    ["hello from #{name}"]
+  end
+  lock_method :get_latest_entries
+  def get_latest_entries2
+    sleep 8
+    ["voo vaa #{name}"]
+  end
+  lock_method :get_latest_entries2, 5 # second
+end
+
+class Blog2
+  class << self
+    def get_latest_entries
+      sleep 8
+      'danke schoen'
+    end
+    lock_method :get_latest_entries
+    def get_latest_entries2
+      sleep 8
+      ["voo vaa #{name}"]
+    end
+    lock_method :get_latest_entries2, 5 # second
+  end
+end
+
+def new_instance_of_my_blog
+  Blog1.new 'my_blog', 'http://my_blog.example.com'
+end
+def new_instance_of_another_blog
+  Blog1.new 'another_blog', 'http://another_blog.example.com'
+end
+
+class Test::Unit::TestCase
+
+end

data/test/shared_tests.rb

@@ -0,0 +1,172 @@
+module SharedTests
+  def test_locked_method_return_value
+    assert_equal ["hello from my_blog"], new_instance_of_my_blog.get_latest_entries
+  end
+  
+  def test_locked_by_normally_terminating_process
+    pid = Kernel.fork { Blog2.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries
+    end
+  
+    # let the blocker finish
+    Process.wait pid
+    
+    assert_nothing_raised do
+      Blog2.get_latest_entries
+    end
+  end
+  
+  def test_locked_by_SIGKILLed_process
+    pid = Kernel.fork { Blog2.get_latest_entries }
+    
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries
+    end
+  
+    # kill it and then wait for it to be reaped
+    Process.detach pid
+    Process.kill 9, pid
+    sleep 1
+    
+    # now we're sure
+    assert_nothing_raised do
+      Blog2.get_latest_entries
+    end
+  end
+  
+  def test_locked_by_killed_thread
+    blocker = Thread.new { Blog2.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries
+    end
+  
+    # kinda like a SIGKILL
+    blocker.kill
+    
+    # now we're sure
+    assert_nothing_raised do
+      Blog2.get_latest_entries
+    end
+  end
+  
+  def test_locked_by_normally_finishing_thread
+    blocker = Thread.new { Blog2.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries
+    end
+  
+    # wait to finish
+    blocker.join
+    
+    # now we're sure
+    assert_nothing_raised do
+      Blog2.get_latest_entries
+    end
+  end
+  
+  def test_lock_instance_method
+    pid = Kernel.fork { new_instance_of_my_blog.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      new_instance_of_my_blog.get_latest_entries
+    end
+  
+    # wait for it
+    Process.wait pid
+    
+    # ok now
+    assert_nothing_raised do
+      new_instance_of_my_blog.get_latest_entries
+    end
+  end
+  
+  def test_clear_instance_method_lock
+    pid = Kernel.fork { new_instance_of_my_blog.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      new_instance_of_my_blog.get_latest_entries
+    end
+  
+    # but now we clear the lock
+    new_instance_of_my_blog.clear_lock :get_latest_entries
+    assert_nothing_raised do
+      new_instance_of_my_blog.get_latest_entries
+    end
+    
+    Process.wait pid
+  end
+  
+  def test_clear_class_method_lock
+    pid = Kernel.fork { Blog2.get_latest_entries }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries
+    end
+    
+    # but now we clear the lock
+    Blog2.clear_lock :get_latest_entries
+    assert_nothing_raised do
+      Blog2.get_latest_entries
+    end
+    
+    Process.wait pid
+  end
+  
+  def test_expiring_lock
+    pid = Kernel.fork { Blog2.get_latest_entries2 }
+  
+    # give it a bit of time to lock
+    sleep 1
+    
+    # the blocker won't have finished
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries2
+    end
+  
+    # still no...
+    sleep 1
+    assert_raises(LockMethod::Locked) do
+      Blog2.get_latest_entries2
+    end
+    
+    # but the lock expiry is 1 second, so by 1.2&change we're done
+    sleep 5
+    assert_nothing_raised do
+      Blog2.get_latest_entries2
+    end
+    
+    Process.wait pid
+  end
+end

data/test/test_default_storage.rb

@@ -0,0 +1,10 @@
+require 'helper'
+
+class TestDefaultStorageClient < Test::Unit::TestCase
+  def setup
+    LockMethod.config.storage = nil
+    LockMethod.storage.flush
+  end
+  
+  include SharedTests
+end

data/test/test_memcached_storage.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+require 'memcached'
+
+class TestMemcachedStorage < Test::Unit::TestCase
+  def setup
+    LockMethod.config.storage = Memcached.new 'localhost:11211'
+    LockMethod.storage.flush
+  end
+    
+  include SharedTests
+end

data/test/test_redis_storage.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+if ENV['REDIS_URL']
+  require 'redis'
+  require 'uri'
+
+  class TestRedisStorage < Test::Unit::TestCase
+    def setup
+      uri = URI.parse(ENV["REDIS_URL"])
+      LockMethod.config.storage = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
+      LockMethod.storage.flush
+    end
+    
+    include SharedTests
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: lock_method
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Seamus Abshere
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-16 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: memcached
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Like alias_method, but it's lock_method!
+email: 
+- seamus@abshere.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/lock_method.rb
+- lib/lock_method/config.rb
+- lib/lock_method/lock.rb
+- lib/lock_method/storage.rb
+- lib/lock_method/storage/default_storage_client.rb
+- lib/lock_method/version.rb
+- lock_method.gemspec
+- test/helper.rb
+- test/shared_tests.rb
+- test/test_default_storage.rb
+- test/test_memcached_storage.rb
+- test/test_redis_storage.rb
+has_rdoc: true
+homepage: https://github.com/seamusabshere/lock_method
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: lock_method
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Lets you lock methods (to memcached, redis, etc.) as though you had a lockfile for each one
+test_files: 
+- test/helper.rb
+- test/shared_tests.rb
+- test/test_default_storage.rb
+- test/test_memcached_storage.rb
+- test/test_redis_storage.rb