restruct 0.0.3 → 0.1.0

data/lib/restruct/structure.rb

@@ -1,31 +1,35 @@
 module Restruct
   class Structure
 
-    attr_reader :redis, :id
+    attr_reader :connection, :id
 
     def initialize(options={})
-      @redis = options[:redis] || Restruct.redis
+      @connection = options[:connection] || Restruct.connection
       @id = Id.new options[:id] || Restruct.generate_id
     end
 
     def ==(object)
       object.class == self.class && 
       object.id == id && 
-      object.redis == redis
+      object.connection == connection
     end
     alias_method :eql?, :==
 
     def dump
-      redis.call 'DUMP', id
+      connection.call 'DUMP', id
     end
 
     def restore(dump)
       destroy
-      redis.call 'RESTORE', id, 0, dump
+      connection.lazy 'RESTORE', id, 0, dump
     end
 
     def destroy
-      redis.call 'DEL', id
+      connection.lazy 'DEL', id
+    end
+
+    def exists?
+      connection.call('EXISTS', id) == 1
     end
     
   end

data/lib/restruct/version.rb

@@ -1,3 +1,3 @@
 module Restruct
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/lua/register.lua

@@ -0,0 +1,21 @@
+local locker_id = ARGV[1]
+local lock_key  = ARGV[2]
+local exclusive = ARGV[3]
+
+if redis.call('EXISTS', locker_id) == 1 then
+  local actual_lock_key = redis.call('HGET', locker_id, 'key')
+  local actual_exclusive = redis.call('HGET', locker_id, 'exclusive')
+
+  local error_message = "Lock " .. lock_key .. " (exclusive=" .. exclusive .. ") fail. Alradey locked by " .. actual_lock_key .. " (exclusive=" .. actual_exclusive .. ")"
+
+  if exclusive == "true" or
+     actual_exclusive == 'true'  or
+     actual_lock_key ~= lock_key then
+    
+    error(error_message)
+  end 
+end
+
+redis.call('HSET', locker_id, 'key', lock_key)
+redis.call('HSET', locker_id, 'exclusive', exclusive)
+redis.call("HINCRBY", locker_id, 'nested', 1)

data/lua/unregister.lua

@@ -0,0 +1,10 @@
+local locker_id = ARGV[1]
+
+if redis.call('EXISTS', locker_id) == 0 then
+  error("Unregister Error. Dont exist key " .. locker_id)
+else
+  redis.call("HINCRBY", locker_id, 'nested', -1)
+  if redis.call('HGET', locker_id, 'nested') == '0' then
+    redis.call('DEL', locker_id)
+  end
+end

data/restruct.gemspec

@@ -18,12 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'redic',        '~> 1.2.0'
+  spec.add_dependency 'redic',        '~> 1.5.0'
   spec.add_dependency 'class_config', '~> 0.0.1'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'minitest', '~> 4.7'
+  spec.add_development_dependency "minitest-great_expectations"
   spec.add_development_dependency 'turn',     '~> 0.9'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'pry-nav'

data/spec/array_spec.rb

@@ -7,7 +7,7 @@ require 'minitest_helper'
     let(:array) { klass.new }
 
     def fill(elements)
-      redis.call 'RPUSH', array.id, *(elements.map { |e| array.send(:serialize, e) })
+      connection.call 'RPUSH', array.id, *(elements.map { |e| array.send(:serialize, e) })
     end
 
     describe 'Getters' do
@@ -333,6 +333,42 @@ require 'minitest_helper'
       other.to_primitive.must_equal array.to_primitive
     end
 
+    it 'Batch' do
+      fill %w(a b c)
+
+      array.connection.batch do
+        array[1] = 'x'                    #a x c
+        array << 'd'                      #a x c d
+        array.shift                       #x c d
+        array.pop(2)                      #x
+        %w(y h z).each {|e| array << e}   #x y h z
+        array.delete 'h'                  #x y z
+        
+        array.to_a.must_equal %w(a b c)
+      end
+
+      array.to_a.must_equal %w(x y z)
+    end
+
+    it 'Restore/Destroy in batch' do
+      fill %w(a b c)
+      
+      dump = array.dump
+      other = klass.new
+
+      array.connection.batch do
+        array.destroy
+        other.restore dump
+        array.must_be :exists?
+        other.wont_be :exists?
+        array.to_a.must_equal %w(a b c)
+      end
+
+      array.wont_be :exists?
+      other.must_be :exists?
+      other.to_a.must_equal %w(a b c)
+    end
+
   end
 
 end

data/spec/connection_spec.rb

@@ -0,0 +1,116 @@
+require 'minitest_helper'
+
+describe Restruct::Connection do
+
+  describe 'Success' do
+    it 'call' do
+      connection.call('HSET', 'test_id', 'key', 'test_key')
+      connection.call('HGET', 'test_id', 'key').must_equal 'test_key'
+    end
+
+    it 'script' do
+      script = %Q{
+        local id = ARGV[1]
+        local key = ARGV[2]
+        local value = ARGV[3]
+        redis.call('HSET', id, key, value)
+        return redis.call('HGET', id, key)
+      }
+      connection.script(script, 0, 'test_id', 'key', 'test_key').must_equal 'test_key'
+    end
+
+    it 'reload script when remove from the redis cache' do
+      script = %Q{
+        local id = ARGV[1]
+        return id
+      }
+      connection.script(script, 0, 'test').must_equal 'test'
+      connection.call 'SCRIPT', 'FLUSH'
+      connection.script(script, 0, 'test').must_equal 'test'
+    end
+
+  end
+
+  describe 'Errors' do
+
+    it 'ArgumentError' do
+      proc { connection.call }.must_raise ArgumentError
+    end
+
+    it 'NoScriptError' do
+      proc { connection.call 'EVALSHA', 'invalid sha', 0 }.must_raise Restruct::NoScriptError
+    end
+
+    it 'Invalid Script' do
+      proc { connection.script 'xyz', 0 }.must_raise Restruct::ConnectionError
+    end
+
+    it 'RuntimeScriptError' do
+      proc { connection.script 'return x', 0 }.must_raise Restruct::ConnectionError
+    end
+
+  end
+
+  describe 'Batch' do
+
+    let (:id) {Restruct.generate_id}
+
+    it 'Execute' do
+      connection.lazy('HSET', id, 'key_1', 'x')
+
+      connection.batch do
+        connection.lazy('HSET', id, 'key_1', 'y')
+        connection.lazy('HSET', id, 'key_2', 'x')
+
+        connection.call('HKEYS', id).must_equal ['key_1']
+        connection.call('HGET', id, 'key_1').must_equal 'x'
+        connection.call('HGET', id, 'key_2').must_be_nil
+      end
+
+      connection.call('HKEYS', id).must_equal ['key_1', 'key_2']
+      connection.call('HGET', id, 'key_1').must_equal 'y'
+      connection.call('HGET', id, 'key_2').must_equal 'x'
+    end
+
+    it 'Discard' do
+      connection.lazy('HSET', id, 'key_1', 'x')
+
+      proc do
+        connection.batch do
+          connection.lazy('HSET', id, 'key_1', 'y')
+          connection.lazy('HSET', id, 'key_2', 'x')
+          raise 'Test error'
+        end
+      end.must_raise RuntimeError
+
+      connection.call('HKEYS', id).must_equal ['key_1']
+      connection.call('HGET', id, 'key_1').must_equal 'x'
+    end
+
+    it 'Nested' do
+      connection.lazy('HSET', id, 'key_1', 'x')
+
+      connection.batch do
+        connection.lazy('HSET', id, 'key_1', 'y')
+        connection.lazy('HSET', id, 'key_2', 'x')
+
+        connection.batch do
+          connection.lazy('HSET', id, 'key_1', 'z')
+          connection.lazy('HSET', id, 'key_2', 'z')
+
+          connection.call('HGET', id, 'key_1').must_equal 'x'
+          connection.call('HGET', id, 'key_2').must_be_nil
+        end
+
+        connection.call('HGET', id, 'key_1').must_equal 'x'
+        connection.call('HGET', id, 'key_2').must_be_nil
+      end
+
+      connection.call('HKEYS', id).must_equal ['key_1', 'key_2']
+      connection.call('HGET', id, 'key_1').must_equal 'z'
+      connection.call('HGET', id, 'key_2').must_equal 'z'
+    end
+
+  end
+
+end

data/spec/hash_spec.rb

@@ -8,7 +8,7 @@ require 'minitest_helper'
 
     def fill(data)
       data.each { |k,v| data[k] = hash.send(:serialize, v) }
-      redis.call 'HMSET', hash.id, *data.flatten
+      connection.call 'HMSET', hash.id, *data.flatten
     end
 
     describe 'Getters' do
@@ -20,7 +20,7 @@ require 'minitest_helper'
         hash[:b].must_equal 'y'
         hash[:c].must_be_nil
       end
-      
+
       it 'fetch' do
         fill a: 'x', b: 'y'
 
@@ -32,7 +32,7 @@ require 'minitest_helper'
         error = proc { hash.fetch(:c) }.must_raise KeyError
         error.message.must_equal 'key not found: c'
       end
-      
+
       it 'key' do
         fill a: 'x', b: 'y', c: 'y'
 
@@ -237,6 +237,20 @@ require 'minitest_helper'
       other.to_primitive.must_equal hash.to_primitive
     end
 
+    it 'Batch' do
+      fill a: 'x', b: 'y', c: 'z'
+
+      hash.connection.batch do
+        hash[:d] = 'w'
+        hash.delete :a
+        hash.merge! b: 'x', e: 'v'
+        
+        hash.to_h.must_equal 'a' => 'x', 'b' => 'y', 'c' => 'z'    
+      end
+
+      hash.to_h.must_equal 'b' => 'x', 'c' => 'z', 'd' => 'w', 'e' => 'v'
+    end
+
   end
 
 end

data/spec/locker_spec.rb

@@ -0,0 +1,161 @@
+require 'minitest_helper'
+
+describe Restruct::Locker do
+
+  let(:locker) { Restruct::Locker.new }
+
+  it 'Flexible' do
+    locker.wont_be :locked?
+
+    locker.lock :process_1 do
+      locker.must_be :locked?
+      locker.locked_by.must_equal 'process_1'
+      
+      locker.lock(:process_1) { }
+      locker.to_h.must_equal({"key"=>"process_1", "exclusive"=>"false", "nested"=>"1"})
+
+      error = proc { locker.lock :process_2 }.must_raise Restruct::LockerError
+      error.message.must_equal 'Lock process_2 (exclusive=false) fail. Alradey locked by process_1 (exclusive=false)'
+    end
+
+    locker.wont_be :locked?
+  end
+
+  it 'Strict' do
+    locker.wont_be :locked?
+
+    locker.lock! :process_1 do
+      locker.must_be :locked?
+      locker.locked_by.must_equal 'process_1'
+
+      error = proc { locker.lock! :process_1 }.must_raise Restruct::LockerError
+      error.message.must_equal 'Lock process_1 (exclusive=true) fail. Alradey locked by process_1 (exclusive=true)'
+
+      error = proc { locker.lock :process_2 }.must_raise Restruct::LockerError
+      error.message.must_equal 'Lock process_2 (exclusive=false) fail. Alradey locked by process_1 (exclusive=true)'
+    end
+
+    locker.wont_be :locked?
+  end
+
+  it 'Force unlock' do
+    connection.call('HSET', locker.id, 'key', :process_1)
+
+    locker.must_be :locked?
+    locker.locked_by.must_equal 'process_1'
+
+    locker.unlock!
+    
+    locker.wont_be :locked?
+  end
+
+  it 'Threads safe' do
+    test_id = Restruct.generate_id[:test]
+
+    threads = 10.times.map do |thread_number|
+      Thread.new do
+        10.times do |iteration|
+          locker.lock :process_1 do
+            connection.call 'RPUSH', test_id, "#{thread_number}-#{iteration}"
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    locker.wont_be :locked?
+
+    expected_list = []
+    10.times do |i|
+      10.times do |j|
+        expected_list << "#{i}-#{j}"
+      end
+    end
+
+    list = connection.call('LRANGE', test_id, 0, -1)
+    list.sort.must_equal expected_list
+    list.wont_equal expected_list
+  end
+
+  if RUBY_ENGINE != 'jruby'
+    it 'Multiples process' do
+      test_id = Restruct.generate_id[:test]
+      locker_id = locker.id
+
+      pids = 10.times.map do |thread_number|
+        Process.fork do
+          connection = Restruct::Connection.new
+          locker = Restruct::Locker.new id: locker_id, connection: connection
+          10.times do |iteration|
+            locker.lock :process_1 do
+              connection.call 'RPUSH', test_id, "#{thread_number}-#{iteration}"
+            end
+          end
+        end
+      end
+
+      Process.waitall
+
+      locker.wont_be :locked?
+
+      expected_list = []
+      10.times do |i|
+        10.times do |j|
+          expected_list << "#{i}-#{j}"
+        end
+      end
+
+      list = connection.call('LRANGE', test_id, 0, -1)
+      list.sort.must_equal expected_list
+    end
+  end
+
+  it 'Return block result' do
+    result = locker.lock :process_1 do
+      'OK'  
+    end
+
+    result.must_equal 'OK'
+  end
+  
+  it 'Unlock when raise error in block' do
+    locker.wont_be :locked?
+
+    proc do
+      locker.lock :process_1 do
+        raise RuntimeError, 'ERROR'
+      end
+    end.must_raise RuntimeError, 'ERROR'
+
+    locker.wont_be :locked?
+  end
+
+  it 'Batch' do
+    id = Restruct.generate_id[:test]
+    connection.lazy('HSET', id, 'key_1', 'x')
+
+    connection.batch do
+      connection.lazy('HSET', id, 'key_1', 'y')
+
+      locker.wont_be :locked?
+      
+      locker.lock :process_1 do
+        locker.must_be :locked?
+        connection.lazy('HSET', id, 'key_2', 'x')
+        locker.lock :process_1 do
+          connection.lazy('HSET', id, 'key_2', 'z')
+          locker.to_h['nested'].must_equal '2'
+        end
+        locker.must_be :locked?
+        locker.to_h['nested'].must_equal '1'
+      end
+
+      locker.wont_be :locked?
+    end
+    connection.call('HKEYS', id).must_equal ['key_1', 'key_2']
+    connection.call('HGET', id, 'key_1').must_equal 'y'
+    connection.call('HGET', id, 'key_2').must_equal 'z'
+  end
+ 
+end