pg_lock 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c24490141a8dd6d9d3903c84120a9635c561a029
+  data.tar.gz: 6e5408ba72c4eed608a141dc34e3778402d7cda9
+SHA512:
+  metadata.gz: 78c5bcf7287fed34d351ab5bb053d28bd0d9da26275ad09f52ef011f36cf188a09ba6239eec991e52d51d3b2c5e63d56232cc9b505486f2049392d9cbb0ad6bd
+  data.tar.gz: d88848d3287d74314e4a8240d7404a3d7e3515da93da5e526f7fc7716070cf3e1188addd4969e5272e6197b60cf04a87d45c23738b9b6c6f5ed2df074f52263b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+  - ruby-head
+
+script:
+  - bundle exec rspec spec
+
+before_script:
+  - psql -c 'create database pg_lock_test;' -U postgres
+
+addons:
+  postgresql: "9.3"
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# A Log of Changes!
+
+## [0.1.0] - 2015-10-06
+
+- First version.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 schneems
+
+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,197 @@
+# PgLock
+
+Uses [Postgres advisory locks](http://www.postgresql.org/docs/9.2/static/view-pg-locks.html) to enable you to syncronize actions across processes and machines.
+
+[![Build Status](https://travis-ci.org/heroku/pg_lock.svg?branch=master)](https://travis-ci.org/heroku/pg_lock)
+
+## Installation
+
+This gem requires Ruby 2.1+
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_lock'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pg_lock
+
+## Usage
+
+Create a `PgLock.new` instance and call the `lock` method to ensure exclusive execution of a block of code.
+
+```ruby
+PgLock.new(name: "all_your_base").lock do
+  # stuff
+end
+```
+
+Now no matter how many times this code is executed across any number of machines, one block of code will be allowed to execute at a time.
+
+## Session based locking
+
+The postgres lock is unique across different database sessions, if the same session tries to aquire the same lock it will succeed. So while `PgLock` will guarantee unique execution across machines and processes, it will not block the same process (sharing the same connection session) from running. For example while you would think the middle block would not run in this example:
+
+```ruby
+key = "all_your_base"
+PgLock.new(name: key).lock do
+  puts "First block called"
+  PgLock.new(name: key).lock do
+    puts "Second block called because it's sharing the same session"
+  end
+end
+```
+
+The result will be:
+
+```
+First block called
+Second block called because it's sharing the same session
+```
+
+If you need to syncronize code execution inside of the same process you should [use a mutex](http://ruby-doc.org/core-2.2.2/Mutex.html).
+
+## Timeout
+
+By default, locked blocks will timeout after 60 seconds of execution, the lock will be released and any code executing will be terminated by a `Timeout::Error` will be raised. You can lower or raise this value by passing in a `ttl` (time to live) argument:
+
+```ruby
+begin
+  PgLock.new(name: "all_your_base", ttl: 30).lock do
+    # stuff
+  end
+rescue Timeout::Error
+  puts "Took longer than 30 seconds to execute"
+end
+```
+
+To disable the timeout pass in a falsey value:
+
+```ruby
+PgLock.new(name: "all_your_base", ttl: false).lock do
+  # stuff
+end
+```
+
+## Retry Attempts
+
+By default if a lock cannot be aquired, `PgLock` will try 3 times with a 1 second delay between tries. You can configure this behavior using `attempts` and `attempt_interval` arguments:
+
+```ruby
+PgLock.new(name: "all_your_base", attempts: 10, attempt_interval: 5).lock do
+  # stuff
+end
+```
+
+To run once use `attempts: 1`.
+
+## Raise Error on Failed Lock
+
+You can optionally raise an error if a block cannot be executed in the given number of attempts by using the `lock!` method:
+
+```ruby
+begin
+  PgLock.new(name: "all_your_base").lock! do
+    # stuff
+  end
+rescue PgLock::UnableToLockError
+  # do stuff
+end
+```
+
+## Manual Lock
+
+The `create` method will return the `PgLock` instance if a lock object was created, or `false` if no lock was aquired. You should manually `delete` a successfully created lock object:
+
+```ruby
+begin
+  lock = PgLock.new(name: "all_your_base")
+  lock.create
+  # do stuff
+ensure
+  lock.delete
+end
+```
+
+You can check on the status of a lock with the `aquired?` method:
+
+```ruby
+begin
+  lock = PgLock.new(name: "all_your_base")
+  lock.create
+  if lock.aquired?
+    # do stuff
+  end
+ensure
+  lock.delete
+end
+```
+
+## Logging
+
+By default there is no logging, if you want you can provide a logging block:
+
+```ruby
+PgLock.new(name: "all_your_base", log: ->(data) { puts data.inspect }).lock do
+  # stuff
+end
+```
+
+One argument will be passed to the block, a hash. You can optionally define a default log for all instances:
+
+```ruby
+PgLock::DEFAULT_LOG = ->(data) { puts data.inspect }
+```
+
+Note: When you enable logging exceptions raised when deleting a lock will be swallowed. To re-raise you can use the exception in `data[:exception]`.
+
+## Database Connection
+
+This library defaults to use Active Record. If you want to use another library, or spin up a dedicated connection you can use the `connection` argument:
+
+```ruby
+my_connection = MyCustomConnectionObject.new
+PgLock.new(name: "all_your_base", connection: my_connection).lock do
+  # stuff
+end
+```
+
+The object needs to respond to the `exec` method where the first argument is a query string, and the second is an array of bind arguments. For example to use with [sequel](https://github.com/jeremyevans/sequel) you could do something like this:
+
+```ruby
+connection = Module do
+  def self.exec(sql, bind)
+    DB.fetch(sql, bind)
+  end
+end
+
+PgLock.new(name: "all_your_base", connection: my_connection).lock do
+  # stuff
+end
+```
+
+Where `DB` is to be your database connection.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/pg_lock/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Acknowledgements
+
+Originally written by [@mikehale](https://github.com/mikehale)

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pg_lock"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pg_lock.rb

@@ -0,0 +1,106 @@
+require 'zlib'
+require 'timeout'
+
+require "pg_lock/version"
+
+class PgLock
+  PG_LOCK_SPACE      = -2147483648
+  DEFAULT_CONNECTION = Proc.new do
+    defined?(ActiveRecord::Base) ? ActiveRecord::Base.connection.raw_connection : false
+  end
+
+  DEFAULT_LOGGER     = Proc.new do
+    defined?(DEFAULT_LOG) ? DEFAULT_LOG : false
+  end
+
+  class UnableToLockError < RuntimeError
+    def initialize(name:, attempts: )
+      msg = "Was unable to aquire a lock #{ name.inspect } after #{ attempts } attempts"
+      super msg
+    end
+  end
+  UnableToLock = UnableToLockError
+
+  def initialize(name:, attempts: 3, attempt_interval: 1, ttl: 60, connection: DEFAULT_CONNECTION.call, log: DEFAULT_LOGGER.call )
+    self.name               = name
+    self.max_attempts       = [attempts, 1].max
+    self.attempt_interval   = attempt_interval
+    self.ttl                = ttl || 0 # set this to 0 to disable the timeout
+    self.log                = log
+
+    connection or raise "Must provide a valid connection object"
+    self.locket             = Locket.new(connection, [PG_LOCK_SPACE, key(name)])
+  end
+
+  # Runs the given block if an advisory lock is able to be acquired.
+  def lock(&block)
+    if create
+      begin
+        Timeout::timeout(ttl, &block) if block_given?
+      ensure
+        delete
+      end
+      return true
+    else
+      return false
+    end
+  end
+
+  # A PgLock::UnableToLock is raised if the lock is not acquired.
+  def lock!(exception_klass = PgLock::UnableToLockError)
+    if lock { yield self if block_given? }
+      # lock successful, do nothing
+    else
+      raise exception_klass.new(name: name, attempts: max_attempts)
+    end
+  end
+
+  def create
+    max_attempts.times.each do |attempt|
+      if locket.lock
+        log.call(at: :create, attempt: attempt, args: locket.args, pg_lock: true) if log
+        return self
+      else
+        return false if attempt.next == max_attempts
+        sleep attempt_interval
+      end
+    end
+  end
+
+  def delete
+    locket.unlock
+    log.call(at: :delete, args: locket.args, pg_lock: true ) if log
+  rescue => e
+    if log
+      log.call(at: :exception, exception: e, pg_lock: true )
+    else
+      raise e
+    end
+  end
+
+  def aquired?
+    locket.active?
+  end
+  alias :has_lock? :aquired?
+
+  private
+    attr_accessor :max_attempts
+    attr_accessor :attempt_interval
+    attr_accessor :connection
+    attr_accessor :locket
+    attr_accessor :ttl
+    attr_accessor :name
+    attr_accessor :log
+
+    def key(name)
+      i = Zlib.crc32(name.to_s)
+      # We need to wrap the value for postgres
+      if i > 2147483647
+        -(-(i) & 0xffffffff)
+      else
+        i
+      end
+    end
+end
+
+require 'pg_lock/locket'

data/lib/pg_lock/locket.rb

@@ -0,0 +1,38 @@
+class PgLock
+  # Holds the logic to aquire a lock and parse if locking was successful
+  class Locket
+    attr_accessor :args, :connection
+    def initialize(connection, lock_args)
+      self.connection = connection
+      self.args       = lock_args
+    end
+
+    def lock
+      @lock = connection.exec("select pg_try_advisory_lock($1,$2)", args)
+      return aquired?
+    end
+
+    def unlock
+      connection.exec("select pg_advisory_unlock($1,$2)", args)
+      @lock = false
+    end
+
+    def aquired?
+      @lock[0]["pg_try_advisory_lock"] == "t"
+    rescue
+      false
+    end
+
+    def active?
+      connection.exec(<<-eos, args).getvalue(0,0) == "t"
+        SELECT granted
+        FROM pg_locks
+        WHERE locktype = 'advisory' AND
+         pid = pg_backend_pid() AND
+         mode = 'ExclusiveLock' AND
+         classid = $1 AND
+         objid = $2
+      eos
+    end
+  end
+end

data/lib/pg_lock/version.rb

@@ -0,0 +1,3 @@
+class PgLock
+  VERSION = "0.1.0"
+end

data/pg_lock.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pg_lock/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pg_lock"
+  spec.version       = PgLock::VERSION
+  spec.authors       = ["mikehale", "schneems"]
+  spec.email         = ["mike@hales.ws", "richard.schneeman@gmail.com"]
+
+  spec.summary       = %q{ Use Postgres advisory lock to isolate code execution across machines }
+  spec.description   = %q{ A Postgres advisory lock client }
+  spec.homepage      = "http://github.com/heroku/pg_lock"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "pg", ">= 0.15"
+  spec.add_development_dependency "activerecord", ">= 2.3"
+  spec.add_development_dependency "bundler", "~> 1"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "rspec", "~> 3.1"
+end
+

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: pg_lock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mikehale
+- schneems
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: " A Postgres advisory lock client "
+email:
+- mike@hales.ws
+- richard.schneeman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/pg_lock.rb
+- lib/pg_lock/locket.rb
+- lib/pg_lock/version.rb
+- pg_lock.gemspec
+homepage: http://github.com/heroku/pg_lock
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Use Postgres advisory lock to isolate code execution across machines
+test_files: []