redis-locker 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+Gemfile.lock
+*.gem
+coverage
+.bundle
+pkg
+spec/config/redis.yml

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "redis"
+gem "logger"
+
+group :test do
+  gem 'rspec'
+end
+
+group :test, :development do
+  gem 'rake'
+end

data/README.md

@@ -0,0 +1,53 @@
+# redis-locker
+
+A super-FAST and super-ROBUST LOCKING mechanism.
+Builds queue of concurrent code blocks using Redis.
+
+If Redis fails at some point (cleared, filled with wrong data, stuck) it will be trying to stay alive anyway. This is supported by additional key-control.
+
+## Installing
+```
+$ gem install redis-locker
+```
+
+Or put in your gemfile for latest version:
+```ruby
+gem 'redis-locker', git: 'git://github.com/einzige/redis-locker.git'
+```
+
+## Using
+```ruby
+# Throws an error if transaction will not be finished in 10 seconds
+RedisLocker.new('payment_transaction').run!(10.seconds) do
+  # Any concurrent code.
+end
+
+# Throws an error if transaction will not be finished in 10 seconds
+# Clears all stale tasks which were not performed within 10 seconds
+RedisLocker.new('payment_transaction', 10.seconds).run! do
+  # Any concurrent code.
+end
+
+# Does not throw any error, but clears all stale tasks which were not performed within 10 seconds
+RedisLocker.new('payment_transaction', 10.seconds).run do
+  # Any concurrent code.
+end
+```
+
+## Running specs
+- Clone the repo
+- run `bundle exec rake spec`
+
+## Contributing to redis-locker
+
+- Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+- Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+- Fork the project
+- Start a feature/bugfix branch
+- Commit and push until you are happy with your contribution
+- Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+- Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2013 Sergei Zinin. No LICENSE for details :)

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+
+ENV['BUNDLE_GEMFILE'] = 'Gemfile'
+gem_root = File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc "Run the test suite"
+task spec: ['spec:setup', 'spec:lib']
+
+namespace :spec do
+  desc "Setup the test environment"
+  task :setup do
+    system "cd #{gem_root} && bundle install && mkdir db"
+  end
+
+  desc "Test the RedisLocker lib"
+  RSpec::Core::RakeTask.new(:lib) do |task|
+    task.pattern = File.join(gem_root, '/spec/lib/**/*_spec.rb')
+  end
+end

data/lib/redis-locker.rb

@@ -0,0 +1,173 @@
+require 'logger'
+require 'redis'
+require 'timeout'
+
+
+class RedisLocker
+  attr_reader :key, :running, :timestamp, :timestamp_key, :time_limit
+
+  # @param [String] key
+  # @param [Integer] time_limit Number of seconds when locker will be expired
+  def initialize(key, time_limit = 5)
+    @key = key
+    @time_limit = time_limit
+    @running = false
+  end
+
+  # @return [true, false]
+  def current?
+    concurrent_timestamp == timestamp
+  end
+
+  # Puts running block information in Redis
+  # This information will be used to place running block in a specific position of its queue
+  def enter_queue
+    logger.info("Entering #@key")
+    raise 'This block is already in the queue' if running?
+
+    @running = true
+    self.timestamp = generate_timestamp.to_s
+
+    redis.set    timestamp_key, '1'
+    redis.expire timestamp_key, time_limit
+    redis.rpush  key, timestamp
+  end
+
+  # Clears all data from queue related to this block
+  def exit_queue
+    logger.info("Leaving #@key")
+    redis.del timestamp_key
+    redis.lrem key, 1, timestamp
+    @running = false
+  end
+
+  # Returns true if block is ready to run
+  # @return [true, false]
+  def get_ready
+    if ready?
+      concurrent_timestamp.nil? ? start_queue : make_current
+      true
+    else
+      current?
+    end
+  end
+
+  def ready?
+    concurrent_timestamp.nil? || current? ||
+        (generate_timestamp - concurrent_timestamp.to_f >= time_limit) ||
+          redis.get(generate_timestamp_key(concurrent_timestamp)).nil?
+  end
+
+  def redis
+    self.class.redis
+  end
+
+  # Waits for the queue and evaluates the block
+  def run(&block)
+    logger.info("Running queue #@key")
+
+    enter_queue
+    wait
+    begin
+      block.call
+    ensure
+      exit_queue
+    end
+  end
+
+  # @param [Integer] time_limit Number of seconds after we throw a Timeout::Error
+  # @param [true, false] clear_queue_on_timeout
+  # @raise [Timeout::Error]
+  def run!(time_limit = @time_limit, clear_queue_on_timeout = false, &block)
+    Timeout::timeout(time_limit) { run(&block) }
+  rescue Timeout::Error => error
+    logger.error("Failed by timeout #{time_limit}s on #@key")
+
+    if clear_queue_on_timeout
+      logger.info("Clearing queue #@key")
+      clear_queue
+    end
+
+    raise error
+  end
+
+  def running?
+    @running
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.redis
+    @redis
+  end
+
+  def self.redis=(adapter)
+    @redis = adapter
+  end
+
+  protected
+
+  # @return [Float]
+  def generate_timestamp
+    Time.now.to_f
+  end
+
+  private
+
+  def clear_queue
+    redis.del key
+  end
+
+  # @return [String]
+  def concurrent_timestamp
+    @concurrent_timestamp ||= fetch_concurrent_timestamp
+  end
+
+  # Fetches next concurrent thread ID from the queue
+  def fetch_concurrent_timestamp
+    redis.lindex(key, 0)
+  end
+
+  # @param [String, Float] timestamp
+  def generate_timestamp_key(timestamp = @timestamp)
+    "Locker::__key_#{timestamp}"
+  end
+
+  # @return [Logger]
+  def logger
+    self.class.logger
+  end
+
+  # Replaces concurrent timestamp
+  def make_current
+    redis.lrem  key, 0, timestamp
+    redis.lpop  key
+    redis.lpush key, timestamp
+  end
+  alias_method :replace_concurrent_timestamp, :make_current
+
+  # Builds queue starting from self
+  def start_queue
+    redis.lpush key, timestamp
+  end
+
+  # @param [Float] value
+  def timestamp=(value)
+    @timestamp = value
+    @timestamp_key = generate_timestamp_key(@timestamp)
+    @timestamp
+  end
+
+  # Locking itself
+  def wait
+    begin
+      @concurrent_timestamp = fetch_concurrent_timestamp
+    end until get_ready
+  end
+end

data/redis-locker.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redis-locker}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sergei Zinin"]
+  s.date = %q{2013-08-13}
+  s.description = %q{A locking mechanism. Builds queue of concurrent code blocks using Redis.}
+  s.email = %q{szinin@partyearth.com}
+  s.extra_rdoc_files = [ "README.md" ]
+  s.files = `git ls-files`.split("\n")
+  s.homepage = %q{http://github.com/einzige/redis-locker}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Destroys the concurrency of your code.}
+
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0')
+    s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_runtime_dependency(%q<logger>, [">= 1.2.8"])
+    s.add_runtime_dependency(%q<redis>, [">= 3.0.3"])
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<logger>, [">= 1.2.8"])
+    s.add_dependency(%q<redis>, [">= 3.0.3"])
+  end
+end

data/spec/config/redis.yml.example

@@ -0,0 +1,2 @@
+host: 127.0.0.1
+port: 6379

data/spec/lib/redis_locker_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+
+describe RedisLocker do
+  let(:queue_name) { 'queue_name' }
+  subject { described_class.new(queue_name, 6) }
+
+  describe "#initialize" do
+    it 'assigns key' do
+      subject.key.should == queue_name
+    end
+
+    it 'assigns time_limit' do
+      subject.time_limit.should == 6
+    end
+  end
+
+  describe "#enter_queue" do
+    context "calling multiple times" do
+      before { subject.enter_queue }
+      its(:running?) { should be_true }
+      it { expect { subject.enter_queue }.to raise_error("This block is already in the queue") }
+
+      context "after exit" do
+        before { subject.exit_queue }
+        its(:running?) { should be_false }
+        it { expect { subject.enter_queue }.not_to raise_error }
+      end
+    end
+  end
+
+  describe "#ready?" do
+    its(:ready?) { should be_true }
+
+    context "trash in a queue" do
+      before do
+        described_class.redis.lpush queue_name, 'whatever'
+      end
+
+      its(:current?) { should be_false }
+      its(:ready?) { should be_true }
+    end
+
+    context "pending timestamp in a queue" do
+      before do
+        subject.enter_queue
+      end
+
+      its(:current?) { should be_true }
+
+      context "stale" do
+        before do
+          described_class.redis.lpush queue_name, subject.timestamp.to_f + 10000
+        end
+
+        its(:current?) { should be_false }
+        its(:ready?) { should be_true }
+      end
+
+      context "not stale" do
+        context "same time" do
+          before do
+            described_class.redis.lpush queue_name, subject.timestamp.to_f
+          end
+
+          its(:current?) { should be_true }
+          its(:ready?) { should be_true }
+        end
+
+        context "later time" do
+          context "same time" do
+            before do
+              described_class.redis.lpush queue_name, subject.timestamp.to_f + 0.00001
+            end
+
+            its(:current?) { should be_false }
+            its(:ready?) { should be_true }
+          end
+        end
+      end
+    end
+
+    context "concurrent threads" do
+      let(:concurrent_locker_1) { described_class.new(queue_name) }
+      let(:concurrent_locker_2) { described_class.new(queue_name) }
+      let(:unrelated_locker) { described_class.new('unrelated') }
+
+      before do
+        concurrent_locker_1.enter_queue
+        concurrent_locker_2.enter_queue
+        unrelated_locker.enter_queue
+      end
+
+      it 'allows first locker in the queue to be run' do
+        concurrent_locker_1.ready?.should be_true
+      end
+
+      it 'makes second locker in the queue wait' do
+        concurrent_locker_2.ready?.should be_false
+      end
+
+      it 'does not have an impact on a separate queue' do
+        unrelated_locker.ready?.should be_true
+      end
+    end
+  end
+
+  describe "#run" do
+    context "with breaking block" do
+      before do
+        subject.should_receive(:exit_queue).once
+      end
+
+      it 'exits queue even if something fails' do
+        expect { subject.run { raise 'PIZDEC!' } }.to raise_error('PIZDEC!')
+      end
+    end
+
+    describe "locking", integrational: true do
+      it 'locks' do
+        looser = nil
+        winner = nil
+
+        concurrent_request = proc do |id|
+          proc do
+            described_class.new(queue_name).run do
+              looser = id
+
+              if winner
+                winner.should_not == looser
+              else
+                winner = id
+                sleep(5)
+              end
+            end
+          end
+        end
+
+        thr_1 = Thread.new &concurrent_request.call(1)
+        thr_2 = Thread.new &concurrent_request.call(2)
+
+        thr_1.join
+        thr_2.join
+      end
+    end
+  end
+
+  describe "#run!" do
+    context "reaching deadline" do
+      before do
+        subject.should_receive(:clear_queue)
+      end
+      it { expect { subject.run!(0.0000000001, true) { sleep(0.00001) } }.to raise_error(Timeout::Error) }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "rspec"
+require "redis-locker"
+require "yaml"
+
+RSpec.configure { |config| config.mock_with :rspec }
+
+redis = Redis.new(YAML.load_file("spec/config/redis.yml"))
+RedisLocker.redis = redis
+RedisLocker.logger.level = Logger::WARN
+
+RSpec.configure do |config|
+  config.filter_run_excluding integrational: true
+
+  config.before { redis.flushdb }
+  config.after { redis.flushdb }
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: redis-locker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sergei Zinin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.8
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.3
+description: A locking mechanism. Builds queue of concurrent code blocks using Redis.
+email: szinin@partyearth.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/redis-locker.rb
+- redis-locker.gemspec
+- spec/config/redis.yml
+- spec/config/redis.yml.example
+- spec/lib/redis_locker_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/einzige/redis-locker
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Destroys the concurrency of your code.
+test_files: []