redis-copy 0.0.6 → 1.0.0.rc.0

data/lib/redis-copy/key-emitter/scan.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module RedisCopy
+  # Scan uses the SCAN family of commands, which were introduced in
+  # the 2.8 branch of Redis, and after 3.0.5 of the redis-rb gem.
+  class KeyEmitter::Scan
+    implements KeyEmitter do |redis, *_|
+      bin_version = Gem::Version.new(redis.info['redis_version'])
+      bin_requirement = Gem::Requirement.new('>= 2.7.105')
+
+      next false unless bin_requirement.satisfied_by?(bin_version)
+
+      redis.respond_to?(:scan_each)
+    end
+
+    def keys
+      @redis.scan_each(count: 1000, match: pattern)
+    end
+  end
+end

data/lib/redis-copy/strategy.rb

@@ -1,29 +1,8 @@
 # encoding: utf-8
 
-require_relative 'strategy/new'
-require_relative 'strategy/classic'
-
 module RedisCopy
   module Strategy
-    # @param source [Redis]
-    # @param destination [Redis]
-    def self.load(source, destination, ui, options = {})
-      strategy = options.fetch(:strategy, :auto).to_sym
-      new_compatible = [source, destination].all?(&New.method(:compatible?))
-      copierklass = case strategy
-                    when :classic then Classic
-                    when :new
-                      raise ArgumentError unless new_compatible
-                      New
-                    when :auto
-                      new_compatible ? New : Classic
-                    end
-      copierklass.new(source, destination, ui, options)
-    end
-
-    def self.included(base)
-      base.send(:include, Verifier)
-    end
+    extend Implements::Interface
 
     # @param source [Redis]
     # @param destination [Redis]
@@ -35,7 +14,7 @@ module RedisCopy
     end
 
     def to_s
-      self.class.name.demodulize.humanize
+      self.class.name.demodulize
     end
 
     # @param key [String]
@@ -87,3 +66,6 @@ module RedisCopy
     end
   end
 end
+
+require_relative 'strategy/classic'
+require_relative 'strategy/dump-restore'

data/lib/redis-copy/strategy/classic.rb

@@ -34,7 +34,7 @@
 module RedisCopy
   module Strategy
     class Classic
-      include Strategy
+      implements Strategy
 
       def copy(key)
         @ui.debug("COPY: #{key.dump}")
@@ -106,10 +106,6 @@ module RedisCopy
       def pipeline_enabled?
         @pipeline_enabled ||= (false | @opt[:pipeline])
       end
-
-      def self.compatible?(redis)
-        true
-      end
     end
   end
 end

data/lib/redis-copy/strategy/{new.rb → dump-restore.rb}

@@ -2,8 +2,17 @@
 
 module RedisCopy
   module Strategy
-    class New
-      include Strategy
+    class DumpRestore
+      implements Strategy do |source, destination, *_|
+        [source, destination].all? do |redis|
+          bin_version = Gem::Version.new(redis.info['redis_version'])
+          bin_requirement = Gem::Requirement.new('>= 2.6.0')
+
+          next false unless bin_requirement.satisfied_by?(bin_version)
+
+          true
+        end
+      end
 
       def copy(key)
         @ui.debug("COPY: #{key.dump}")
@@ -21,14 +30,6 @@ module RedisCopy
         @ui.debug("ERROR: #{error}")
         return false
       end
-
-      def self.compatible?(redis)
-        maj, min, *_ = redis.info['redis_version'].split('.').map(&:to_i)
-        return false unless maj >= 2
-        return false unless min >= 6
-
-        return true
-      end
     end
   end
 end

data/lib/redis-copy/strategy/interface.spec.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+
+# The shared examples for RedisCopy::Strategy are available to require
+# into consuming libraries so they can verify their implementation of the
+# RedisCopy::Strategy interface. See the bundled specs for the bundled
+# key-emitters for example usage.
+if defined?(::RSpec)
+  shared_examples_for(RedisCopy::Strategy) do
+    let(:strategy_class) { described_class }
+    let(:options) { Hash.new } # append using before(:each) { options.update(foo: true) }
+    let(:ui) { RedisCopy::UI::CommandLine.new(options) }
+    let(:selector) { strategy_class.name.underscore.dasherize } # see implements gem
+    let(:strategy_class_finder) { RedisCopy::Strategy.implementation(selector) }
+    let(:strategy) { strategy_class_finder.new(source, destination, ui, options) }
+    let(:multiplex) { RedisMultiplex.new(source, destination) }
+    let(:source) { Redis.new(REDIS_OPTIONS.merge(db: 14)) }
+    let(:destination) { Redis.new(REDIS_OPTIONS.merge(db: 15)) }
+
+    let(:key) { rand(16**128).to_s(16) }
+    after(:each) { multiplex.both { |redis| redis.del(key) } }
+    let(:ttl) { 100 }
+
+    before(:each) do
+      begin
+        strategy.class.should eq strategy_class
+      rescue Implements::Implementation::NotFound
+        pending "#{strategy_class} not supported in your environment"
+      end
+    end
+
+    context '#copy' do
+      before(:each) { populate.call }
+      context 'string' do
+        let(:source_string) { rand(16**256).to_s(16) }
+        let(:populate) { proc {source.set(key, source_string)} }
+        [true,false].each do |with_expiry|
+          context "with_expiry(#{with_expiry})" do
+            before(:each) { source.expire(key, ttl) } if with_expiry
+            context 'before' do
+              context 'source' do
+                let(:redis) { source }
+                subject { source.get(key) }
+                it { should_not be_nil }
+                it { should eq source_string }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.get(key) }
+                it { should be_nil }
+                it_should_behave_like :no_ttl
+              end
+            end
+
+            context 'after' do
+              before(:each) { strategy.copy(key) }
+              context 'source' do
+                let(:redis) { source }
+                subject { source.get(key) }
+                it { should_not be_nil }
+                it { should eq source_string }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.get(key) }
+                it { should_not be_nil }
+                it { should eq source_string }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              it_should_behave_like '#verify?'
+            end
+          end
+        end
+      end
+
+      context 'list' do
+        let(:source_list) do
+          %w(foo bar baz buz bingo jango)
+        end
+        let(:populate) { proc { source_list.each{|x| source.rpush(key, x)} } }
+        [true,false].each do |with_expiry|
+          context "with_expiry(#{with_expiry})" do
+            before(:each) { source.expire(key, 100) } if with_expiry
+            context 'before' do
+              context 'source' do
+                let(:redis) { source }
+                subject { source.lrange(key, 0, -1) }
+                it { should_not be_empty }
+                it { should eq source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.lrange(key, 0, -1) }
+                it { should be_empty }
+                it_should_behave_like :no_ttl
+              end
+            end
+
+            context 'after' do
+              before(:each) { strategy.copy(key) }
+              context 'source' do
+                let(:redis) { source }
+                subject { source.lrange(key, 0, -1) }
+                it { should_not be_empty }
+                it { should eq source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.lrange(key, 0, -1) }
+                it { should_not be_empty }
+                it { should eq source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              it_should_behave_like '#verify?'
+            end
+          end
+        end
+      end
+
+      context 'set' do
+        let(:source_list) do
+          %w(foo bar baz buz bingo jango)
+        end
+        let(:populate) { proc { source_list.each{|x| source.sadd(key, x)} } }
+        [true,false].each do |with_expiry|
+          context "with_expiry(#{with_expiry})" do
+            before(:each) { source.expire(key, 100) } if with_expiry
+            context 'before' do
+              context 'source' do
+                let(:redis) { source }
+                subject { source.smembers(key) }
+                it { should_not be_empty }
+                it { should =~ source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.smembers(key) }
+                it { should be_empty }
+                it_should_behave_like :no_ttl
+              end
+            end
+
+            context 'after' do
+              before(:each) { strategy.copy(key) }
+              context 'source' do
+                let(:redis) { source }
+                subject { source.smembers(key) }
+                it { should_not be_empty }
+                it { should =~ source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.smembers(key) }
+                it { should_not be_empty }
+                it { should =~ source_list }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+            end
+          end
+        end
+      end
+
+      context 'hash' do
+        let(:source_hash) do
+          {
+            'foo' => 'bar',
+            'baz' => 'buz'
+          }
+        end
+        let(:populate) { proc { source.mapped_hmset(key, source_hash) } }
+        [true,false].each do |with_expiry|
+          context "with_expiry(#{with_expiry})" do
+            before(:each) { source.expire(key, 100) } if with_expiry
+            context 'before' do
+              context 'source' do
+                let(:redis) { source }
+                subject { source.hgetall(key) }
+                it { should_not be_empty }
+                it { should eq source_hash }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.hgetall(key) }
+                it { should be_empty }
+                it_should_behave_like :no_ttl
+              end
+            end
+
+            context 'after' do
+              before(:each) { strategy.copy(key) }
+              context 'source' do
+                let(:redis) { source }
+                subject { source.hgetall(key) }
+                it { should_not be_empty }
+                it { should eq source_hash }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.hgetall(key) }
+                it { should_not be_empty }
+                it { should eq source_hash }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              it_should_behave_like '#verify?'
+            end
+          end
+        end
+      end
+
+      context 'zset' do
+        let(:source_zset) do
+          {
+            'foo' => 1.0,
+            'baz' => 2.5,
+            'bar' => 1.1,
+            'buz' => 2.7
+          }
+        end
+        let(:vs_source_zset) { source_zset.to_a }
+        let(:sv_source_zset) { vs_source_zset.map(&:reverse) }
+        let(:populate) { proc { source.zadd(key, sv_source_zset) } }
+        [true,false].each do |with_expiry|
+          context "with_expiry(#{with_expiry})" do
+            before(:each) { source.expire(key, 100) } if with_expiry
+            context 'before' do
+              context 'source' do
+                let(:redis) { source }
+                subject { source.zrange(key, 0, -1, :with_scores => true) }
+                it { should_not be_empty }
+                it { should =~ vs_source_zset }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.zrange(key, 0, -1, :with_scores => true) }
+                it { should be_empty }
+                it_should_behave_like :no_ttl
+              end
+            end
+
+            context 'after' do
+              before(:each) { strategy.copy(key) }
+              context 'source' do
+                let(:redis) { source }
+                subject { source.zrange(key, 0, -1, :with_scores => true) }
+                it { should_not be_empty }
+                it { should =~ vs_source_zset }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              context 'destination' do
+                let(:redis) { destination }
+                subject { destination.zrange(key, 0, -1, :with_scores => true) }
+                it { should_not be_empty }
+                it { should =~ vs_source_zset }
+                it_should_behave_like (with_expiry ? :ttl_set : :no_ttl)
+              end
+              it_should_behave_like '#verify?'
+            end
+          end
+        end
+      end
+    end
+  end
+
+  shared_examples_for(:no_ttl) do
+    # key, redis,
+    subject { redis.ttl(key) }
+    it { should be < 0 }
+  end
+
+  shared_examples_for(:ttl_set) do
+    # key, redis, ttl
+    subject { redis.ttl(key) }
+    it { should be_within(1).of(ttl) }
+  end
+
+  shared_examples_for '#verify?' do
+    before(:each) do
+      ui.stub(:debug).and_call_original
+      ui.stub(:notify) do |message|
+        puts message
+      end
+    end
+    it 'should verify successfully' do
+      strategy.verify?(key).should be_true
+    end
+  end
+else
+  fail(LoadError,
+       "#{__FILE__} contains shared examples for RedisCopy::Strategy. " +
+       "Require it in your specs, not your code.")
+end

data/lib/redis-copy/ui.rb

@@ -1,16 +1,8 @@
 # encoding: utf-8
 
-require_relative 'ui/auto_run'
-require_relative 'ui/command_line'
-
 module RedisCopy
   module UI
-    def self.load(options = {})
-      ui = options.fetch(:ui, :auto_run)
-      const_name = ui.to_s.camelize
-      require "redis-copy/ui/#{ui}" unless const_defined?(const_name)
-      const_get(const_name).new(options)
-    end
+    extend Implements::Interface
 
     def initialize(options)
       @options = options
@@ -36,3 +28,7 @@ module RedisCopy
     end
   end
 end
+
+# load the bundled uis:
+require_relative 'ui/auto_run'
+require_relative 'ui/command_line'