system_lock 0.9.1

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Rodney Carvalho
+
+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

@@ -0,0 +1,53 @@
+System Lock
+===========
+
+System Lock is a system-wide critical section for ruby code.  This works across multiple mongrel/thin instances 
+across multiple servers.  This also works with recursive calls to the lock by using reference counting.  The
+information required for the lock is stored in memcached.
+
+Requirements
+============
+
+Memcached Server
+Dalli Gem
+
+What you need to know
+====================
+
+1) Set this after you initialize memcached.  CACHE is the instance of
+DALLI e.g. "CACHE = Dalli::Client.new(SERVER_LIST, {:username = "XXXXXX", :password => "XXXXXX"})"
+
+  Internaut::SystemLock.memcached_instance = CACHE
+
+If you are in Rails you can use the following in your environment.rb:
+	
+  Internaut::SystemLock.memcached_instance = Rails.cache
+  
+2) Setup your lock around the code you want to protect.  The unique identifier should be something that identifies
+not only the code block, but in which cases you want it to be protected.  For example, in this case I am using
+something that looks like a route or url.  I want to protect this code block for all users trying to access
+project id 152.
+
+  Internaut::SystemLock.critical_section('/projects/152') do
+    # any code that you execute in here will be serialized as long 
+    # as it has the same unique code block identifier
+  end
+
+API
+===
+Internaut::SystemLock.memcached_instance(MEMCACHED_INSTANCE)
+
+Internaut::SystemLock.critical_section(unique_code_block_identifier, timeout=60) 
+  # Timeout default 60 seconds.  Set it higher than you need it to be.
+
+Internaut::SystemLock.disable!
+Internaut::SystemLock.enable! (enabled by default)
+Internaut::SystemLock.enabled?
+
+
+Information stored in Memcached
+===============================
+unique_code_block_identifier => [ process_id + unique_server_id_string, reference_count ]
+
+
+Copyright (c) 2009 Rodney Carvalho, released under the MIT license

data/lib/system_lock.rb

@@ -0,0 +1,115 @@
+# timeout must be longer than it takes to execute code block
+module Internaut
+  class CacheTest
+    @@path = 'SystemLock::internaut_test_values'
+    def self.add(value)
+      if val = result
+        value = "#{val},#{value}"
+      end
+      SystemLock.memcached_instance.set @@path, value, 60.seconds.to_i
+    end
+
+    def self.result
+      SystemLock.memcached_instance.get(@@path)
+    end
+    
+    def self.clear
+      SystemLock.memcached_instance.set @@path, nil
+    end
+  end
+
+  class SystemLock
+    @@enabled = true
+
+    def self.disable!
+      @@enabled = false
+    end
+
+    def self.enable!
+      @@enabled = true
+    end
+
+    def self.enabled?
+      @@enabled
+    end
+    
+    def self.memcached_instance= cache
+      @@CACHE = cache
+    end
+    
+    def self.memcached_instance
+      @@CACHE
+    end
+
+    def self.critical_section(unique_code_block_identifier, timeout=60)
+      # puts "entering cc #{Process.pid}"
+      yield and return unless @@enabled
+
+      begin
+        path = "SystemLock::#{unique_code_block_identifier}"
+        # puts "waiting for lock..."
+        # wait until the lock is released or until we timeout
+
+        # We use a combination of the process id and a unique app id in case the process id is the same on two different machines
+        unique_process_id = UNIQUE_APPLICATION_INSTANCE_ID + Process.pid.to_s
+        got_the_lock = false
+        while( !got_the_lock )
+          while( (cache = @@CACHE.get(path)) && (cache[0] != unique_process_id) rescue return ) do
+            # puts "locked waiting.... #{path}: #{Process.pid} : #{cache.inspect}"
+            sleep(0.1)
+          end
+          
+          counter = cache && cache[1]
+          counter ||= 0
+          # set the lock
+          set_lock_to = [unique_process_id,counter]
+          # puts "attempting to grab lock: #{set_lock_to.inspect}"
+          @@CACHE.set( path, set_lock_to, timeout.seconds.to_i )
+          cache = @@CACHE.get(path)
+          if cache && (cache[0] == unique_process_id)
+            # we have to double check to make sure we actually got the lock
+            # sleep(0.1)
+            cache = @@CACHE.get(path)
+            if cache && (cache[0] == unique_process_id)
+              # puts "got the lock"
+              got_the_lock = true
+              
+              # puts "grabbing lock: #{set_lock_to.inspect}"
+              # add reference - we use ref counting for recursive calls
+              set_lock_to = [unique_process_id,cache[1]+1]
+              @@CACHE.set( path, set_lock_to, timeout.seconds.to_i ) 
+            else
+              redo
+            end
+          else
+            # puts "redoing: #{RefCounter.get(path)}, #{unique_process_id}"
+            redo
+          end
+        end
+        # puts "acquired lock #{Process.pid}"
+        CacheTest.add "entering #{Process.pid}" if Rails.env.test?
+
+        # Do the action
+        yield
+
+        CacheTest.add "exiting #{Process.pid}" if Rails.env.test?
+        # puts "leaving lock #{Process.pid}"
+      # make sure we always unlock, even if there is an exception
+      ensure
+        cache = @@CACHE.get(path)
+        if cache
+          if cache[1] > 1
+            
+            cache[1] -= 1
+            # puts "decrementing count to #{cache.inspect}"
+            @@CACHE.set( path, cache)
+          else
+            @@CACHE.set( path, nil)
+            # puts "decrementing count to nil - #{path}"
+          end
+        end
+      end
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: system_lock
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+  prerelease: 
+platform: ruby
+authors:
+- rcarvalho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-16 00:00:00.000000000Z
+dependencies: []
+description: System Lock is a system-weide Ruby Critical Section that uses Memcached
+  to lock
+email: i@rodneyc.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/system_lock.rb
+- MIT-LICENSE
+- README
+homepage: http://github.com/rcarvalho/system_lock
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby system-wide lock using memcached
+test_files: []