palsy 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60fb2ba51b992f7b83ce4d94f0999bbdd57ba8a7
+  data.tar.gz: b52c06df6875bade0c18b0261c19ee2c1c27c51a
+SHA512:
+  metadata.gz: ba0b46d264bd49e24ed3780827705ab7a17a7cf1145a6e81beb903ec2fcfcd79f986ea7c5e564b48b5ac26fc8183cd2f2b8d42a7bccb2a83cb4fce63d395a84a
+  data.tar.gz: aa00113a932da3527a871e940493d099698c42d025b8d6093f27ccb1b1a95397c67705465c649964494ce5c44354e6cbdb3781a66aed4973eaf2b9b4d16abdf9

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+* 0.0.4 - April 6, 2013
+  * This takes the changes in 0.0.3 and improves robustness over high-volume
+    concurrency and improves transaction isolation for single operations.
 * 0.0.3 - April 2, 2013
   * Ensure exclusive transactions are being used for all operations. This
     should make it a little more viable for non-MRI things.

data/lib/palsy.rb

@@ -1,6 +1,7 @@
 require 'sqlite3'
 require 'singleton'
 require 'delegate'
+require 'thread'
 require "palsy/version"
 
 # Present ruby core data structures in a manner similar to perl's tie backed by a
@@ -67,6 +68,7 @@ class Palsy < DelegateClass(SQLite3::Database)
   # working with the rest of the library.
   #
   def initialize
+    @palsy_lock = Mutex.new
     super(connect)
   end
 
@@ -88,15 +90,72 @@ class Palsy < DelegateClass(SQLite3::Database)
     end
   end
 
+  # Override the explicit lock for the current thread. For things that generate
+  # queries, will not attempt to acquire a mutex, will not attempt to run a
+  # transaction. Will just run the block. See #with_t for information on lock
+  # semantics.
+  #
+  # For Ruby 2.0 users and above: If you wrap your palsy operations in #no_lock
+  # on the current thread, #with_t will not try to use a mutex lock or
+  # transaction.
+  #
+  # This is useful if you want to use palsy in a signal handler:
+  #
+  #     trap("INFO") do
+  #       Palsy.instance.no_lock do
+  #         some_palsy_thing
+  #       end
+  #     end
+  #
+  # The caveat is that any writes done in this region will not be isolated and
+  # will likely cause problems.
+  #
+  def no_lock
+    retval = nil
+    Thread.current[:palsy_no_lock] = true
+    retval = yield
+    Thread.current[:palsy_no_lock] = false
+    return retval
+  end
+
+  #
+  # Start a mutex-wrapped exclusive transaction, then execute the block. If
+  # we're already the owner of the transaction, just execute.
+  #
+  # This is used by most things in Palsy. If you want to step around the lock
+  # (necessary for specific situations, and has certain caveats), take a look
+  # at #no_lock.
+  #
+  def with_t
+    result = nil
+    tc = Thread.current
+
+    if tc[:lock] or tc[:palsy_no_lock]
+      result = yield
+    else
+      @palsy_lock.synchronize do
+        begin
+          tc[:lock] = @palsy_lock
+          transaction(:exclusive) { result = yield }
+        rescue StandardError => e
+          rollback if transaction_active?
+          raise e
+        ensure
+          tc[:lock] = nil
+        end
+      end
+    end
+
+    return result
+  end
+
   #
   # Execute this query in an exclusive transaction.
   #
   def execute_t(query, args=[], &block)
     result = nil
 
-    transaction(:exclusive) do
-      result = execute(query, args, &block)
-    end
+    with_t { result = execute(query, args, &block) }
 
     return result
   end

data/lib/palsy/basic/list.rb

@@ -49,16 +49,23 @@ class Palsy
     # Add a value to the head of the list.
     #
     def unshift(val)
-      replace([val] + to_a)
+      @db.with_t do
+        replace([val] + to_a)
+      end
     end
 
     #
     # Helper method for mutators.
     #
     def mutate(meth)
-      a = to_a
-      val = a.send(meth)
-      replace(a)
+      val = nil
+
+      @db.with_t do
+        a = to_a
+        val = a.send(meth)
+        replace(a)
+      end
+
       return val
     end
 
@@ -81,15 +88,17 @@ class Palsy
     # like an Enumerable.
     #
     def replace(ary)
-      clear
-      return if ary.count == 0
+      @db.with_t do
+        clear
+        return if ary.count == 0
 
-      value_string = ("(?, ?)," * ary.count).chop
+        value_string = ("(?, ?)," * ary.count).chop
 
-      @db.execute_t(
-          "insert into #{@table_name} (name, value) values #{value_string}",
-          ary.map { |x| [@object_name, Marshal.dump(x)] }.flatten
-      )
+        @db.execute_t(
+            "insert into #{@table_name} (name, value) values #{value_string}",
+            ary.map { |x| [@object_name, Marshal.dump(x)] }.flatten
+        )
+      end
     end
 
     #

data/lib/palsy/basic/map.rb

@@ -49,18 +49,37 @@ class Palsy
     # database before attempting to write the new pair.
     #
     def []=(key, value)
-      delete(key)
-      @db.execute_t("insert into #{@table_name} (name, key, value) values (?, ?, ?)", [@object_name, Marshal.dump(key), Marshal.dump(value)])
+      @db.with_t do
+        delete(key)
+        @db.execute_t("insert into #{@table_name} (name, key, value) values (?, ?, ?)", [@object_name, Marshal.dump(key), Marshal.dump(value)])
+      end
       value
     end
 
+    #
+    # replace this map with the contents of a Hash.
+    #
+    def replace(hash)
+      @db.with_t do
+        clear
+
+        return if hash.keys.empty?
+
+        value_string = ("(?, ?, ?)," * hash.keys.count).chop
+
+        @db.execute_t("insert into #{@table_name} (name, key, value) values #{value_string}", hash.map { |key, value| [@object_name, Marshal.dump(key), Marshal.dump(value)] }.flatten)
+      end
+    end
+
     #
     # Successively yields key and value for each item in the map. Modifications
     # to either the key or value yielded will not persist.
     #
     def each
-      keys.each do |key|
-        yield key, self[key]
+      @db.with_t do
+        keys.each do |key|
+          yield key, self[key]
+        end
       end
     end
 

data/lib/palsy/basic/object.rb

@@ -27,7 +27,13 @@ class Palsy
     # Get an object by referencing its key. Returns nil unless it exists.
     #
     def [](key)
-      value = @db.execute_t("select value from #{@table_name} where key=?", [key]).first.first rescue nil
+      value = begin
+                ret = @db.execute_t("select value from #{@table_name} where key=?", [key])
+                (ret && ret.first) ? ret.first.first : nil
+              rescue SQLite3::Exception
+                nil
+              end
+
       return value && Marshal.load(value)
     end
 
@@ -35,8 +41,10 @@ class Palsy
     # Set an object. Returns the object. The object must be able to be Marshalled.
     #
     def []=(key, value)
-      delete(key)
-      @db.execute_t("insert into #{@table_name} (key, value) values (?, ?)", [key, Marshal.dump(value)])
+      @db.with_t do
+        delete(key)
+        @db.execute_t("insert into #{@table_name} (key, value) values (?, ?)", [key, Marshal.dump(value)])
+      end
       value
     end
 

data/lib/palsy/basic/set.rb

@@ -41,8 +41,10 @@ class Palsy
     # avoid raising a constraint from sqlite.
     #
     def add(key)
-      delete(key)
-      @db.execute_t("insert into #{@table_name} (name, key) values (?, ?)", [@object_name, Marshal.dump(key)])
+      @db.with_t do
+        delete(key)
+        @db.execute_t("insert into #{@table_name} (name, key) values (?, ?)", [@object_name, Marshal.dump(key)])
+      end
     end
 
     #
@@ -73,13 +75,15 @@ class Palsy
     # set, or any Enumerable that has a set of unique values.
     #
     def replace(set)
-      clear
+      @db.with_t do
+        clear
 
-      return if set.empty?
+        return if set.empty?
 
-      value_string = ("(?, ?)," * set.count).chop
+        value_string = ("(?, ?)," * set.count).chop
 
-      @db.execute_t("insert into #{@table_name} (name, key) values #{value_string}", set.map { |x| [@object_name, Marshal.dump(x)] }.flatten)
+        @db.execute_t("insert into #{@table_name} (name, key) values #{value_string}", set.map { |x| [@object_name, Marshal.dump(x)] }.flatten)
+      end
     end
 
     #

data/lib/palsy/version.rb

@@ -1 +1 @@
-PalsyVersion = "0.0.3"
+PalsyVersion = "0.0.4"

data/test/helper.rb

@@ -7,6 +7,7 @@ end
 
 require 'minitest/unit'
 require 'tempfile'
+require 'timeout'
 require 'palsy'
 
 module Palsy::TestHelper

data/test/test_init.rb

@@ -38,4 +38,19 @@ class TestInit < MiniTest::Unit::TestCase
     Palsy.reconnect
     assert_raises(NoMethodError) { Palsy.instance.closed? }
   end
+
+  def test_with_t
+    dbfile = new_dbfile
+    Palsy.change_db(dbfile.path)
+
+    (0..2).map do
+      Thread.new do
+        assert_raises(ArgumentError) do
+          Palsy.instance.with_t do
+            raise ArgumentError
+          end
+        end
+      end
+    end.map(&:join)
+  end
 end

data/test/test_list.rb

@@ -15,6 +15,46 @@ class TestList < PalsyTypeTest
     t.each(&:join)
 
     assert_equal(syms.sort, @list.to_a.sort)
+
+    writer = Thread.new { loop { @list.push(rand.to_i) } }
+    reader = Thread.new { loop { @list.shift } }
+
+    begin
+      Timeout.timeout(10) do
+        writer.join
+        reader.join
+      end
+    rescue TimeoutError
+      pass "push and shift competed for 10 seconds without any exceptions"
+      writer.raise
+      reader.raise
+      writer.join rescue nil
+      reader.join rescue nil
+    end
+
+    replacer = Thread.new { loop { @list.replace(Set[1,2,3]) } }
+    clearer = Thread.new { loop { @list.clear } }
+
+    begin
+      Timeout.timeout(10) do
+        replacer.join
+        clearer.join
+      end
+    rescue TimeoutError
+      pass "replace and clear competed for 10 seconds without any exceptions"
+      replacer.raise
+      clearer.raise
+      replacer.join rescue nil
+      clearer.join rescue nil
+    end
+
+    refute(@list.db.transaction_active?)
+
+    # XXX there's no solid way of knowing what'll be in here without inserting
+    # locks which will actually defeat the point of the test. Check the type,
+    # which will cause an execution and ensure we don't have a stale
+    # transaction.
+    assert_kind_of(Array, @list.to_a)
   end
 
   def test_semantics

data/test/test_map.rb

@@ -16,6 +16,46 @@ class TestMap < PalsyTypeTest
     t.each(&:join)
 
     assert_equal(@map.to_hash, args)
+
+    writer = Thread.new { loop { @map[rand.to_i] = 1 } }
+    reader = Thread.new { loop { @map.keys } }
+
+    begin
+      Timeout.timeout(10) do
+        writer.join
+        reader.join
+      end
+    rescue TimeoutError
+      pass "[] and keys competed for 10 seconds without any exceptions"
+      writer.raise
+      reader.raise
+      writer.join rescue nil
+      reader.join rescue nil
+    end
+
+    replacer = Thread.new { loop { @map.replace(Hash[[1,2,3].zip([2,3,4])]) } }
+    clearer = Thread.new { loop { @map.clear } }
+
+    begin
+      Timeout.timeout(10) do
+        replacer.join
+        clearer.join
+      end
+    rescue TimeoutError
+      pass "replace and clear competed for 10 seconds without any exceptions"
+      replacer.raise
+      clearer.raise
+      replacer.join rescue nil
+      clearer.join rescue nil
+    end
+
+    refute(@map.db.transaction_active?)
+
+    # XXX there's no solid way of knowing what'll be in here without inserting
+    # locks which will actually defeat the point of the test. Check the type,
+    # which will cause an execution and ensure we don't have a stale
+    # transaction.
+    assert_kind_of(Hash, @map.to_hash)
   end
 
   def test_inherits
@@ -86,4 +126,17 @@ class TestMap < PalsyTypeTest
       assert_equal(@map[k], v, "#each yields each value")
     end
   end
+
+  def test_replace
+    @map[1] = "foo"
+    assert_equal("foo", @map[1])
+
+    hash = {2 => "bar", 3 => "foo"}
+
+    @map.replace(hash)
+    refute_equal("foo", @map[1])
+    assert_equal("bar", @map[2])
+    assert_equal("foo", @map[3])
+    assert_equal(hash, @map.to_hash)
+  end
 end

data/test/test_object.rb

@@ -14,6 +14,41 @@ class TestObject < PalsyTypeTest
     args.each do |k,v|
       assert_equal(obj[k], args[k])
     end
+
+    writer = Thread.new { loop { obj["1"] = "1" } }
+    reader = Thread.new { loop { obj["1"] } }
+
+    begin
+      Timeout.timeout(10) do
+        writer.join
+        reader.join
+      end
+    rescue TimeoutError
+      pass "[]= and [] competed for 10 seconds without any exceptions"
+      writer.raise
+      reader.raise
+      writer.join rescue nil
+      reader.join rescue nil
+    end
+
+    replacer = Thread.new { loop { obj[1] = 1 } }
+    clearer = Thread.new { loop { obj.delete(1) } }
+
+    begin
+      Timeout.timeout(10) do
+        replacer.join
+        clearer.join
+      end
+    rescue TimeoutError
+      pass "[]= and delete competed for 10 seconds without any exceptions"
+      replacer.raise
+      clearer.raise
+      replacer.join rescue nil
+      clearer.join rescue nil
+    end
+
+    refute(obj.db.transaction_active?)
+    obj.delete(1)
   end
 
   def test_index

data/test/test_set.rb

@@ -15,6 +15,61 @@ class TestSet < PalsyTypeTest
     t.each(&:join)
 
     assert_equal(syms.sort, @set.to_a.sort)
+
+    writer = Thread.new { loop { @set.add(rand.to_i) } }
+    reader = Thread.new { loop { @set.keys } }
+
+    begin
+      Timeout.timeout(10) do
+        writer.join
+        reader.join
+      end
+    rescue TimeoutError
+      pass "add and keys competed for 10 seconds without any exceptions"
+      writer.raise
+      reader.raise
+      writer.join rescue nil
+      reader.join rescue nil
+    end
+
+    replacer = Thread.new { loop { @set.replace(Set[1,2,3]) } }
+    clearer = Thread.new { loop { @set.clear } }
+
+    begin
+      Timeout.timeout(10) do
+        replacer.join
+        clearer.join
+      end
+    rescue TimeoutError
+      pass "replace and clear competed for 10 seconds without any exceptions"
+      replacer.raise
+      clearer.raise
+      replacer.join rescue nil
+      clearer.join rescue nil
+    end
+
+    refute(@set.db.transaction_active?)
+
+    # XXX there's no solid way of knowing what'll be in here without inserting
+    # locks which will actually defeat the point of the test. Check the type,
+    # which will cause an execution and ensure we don't have a stale
+    # transaction.
+    assert_kind_of(Set, @set.to_set)
+  end
+
+  def test_enumerable_freebies
+    (0..10).each { |x| @set.add(x) }
+    real_set = @set.to_set
+    assert_kind_of(Set, real_set)
+    assert_equal(Set[*(0..10).to_a], real_set)
+    array = @set.to_a
+    assert_kind_of(Array, array)
+    assert_equal((0..10).to_a, array.sort)
+
+    t = (0..2).map { Thread.new { @set.to_set } }
+    t.each(&:join)
+
+    t = (0..2).map { Thread.new { @set.to_a } }
   end
 
   def test_semantics

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: palsy
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 0.0.4
 platform: ruby
 authors:
 - Erik Hollensbe
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-02 00:00:00.000000000 Z
+date: 2013-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -46,23 +41,20 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -78,39 +69,34 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -118,7 +104,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -126,17 +111,15 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: An extremely simple marshalling persistence layer for SQLite based on
@@ -174,33 +157,26 @@ files:
 - test/test_set.rb
 homepage: ''
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3156010217290385344
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3156010217290385344
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An extremely simple marshalling persistence layer for SQLite based on perl's
   tie()
 test_files: