ccp 0.3.4 → 0.3.5

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 .bundle
+.ruby-version
 Gemfile.lock
 pkg/*
 tmp/*

data/lib/ccp/kvs/core.rb

@@ -5,7 +5,6 @@ module Ccp
       def set(k,v) ; raise NotImplementedError, "subclass resposibility"; end
       def del(k)   ; raise NotImplementedError, "subclass resposibility"; end
       def keys     ; raise NotImplementedError, "subclass resposibility"; end
-      def read!    ; keys.inject({}){|h,k| h[k] = get(k); h }           ; end
       def exist?(k); !! get(k)                                          ; end
       def key?(k)  ; exist?(k)                                          ; end
 
@@ -32,6 +31,16 @@ module Ccp
           def self.open(*args); new.tap{|kvs| kvs.open(*args)}; end
         end
       end
+
+      # bulk operation
+      def read     ; keys.inject({}){|h,k| h[k] = get(k); h }           ; end
+      def write(h) ; h.each_pair{|k,v| set(k,v)}                        ; end
+
+      # backward compat (until 0.3.6)
+      def read!
+        STDERR.puts "DEPRECATION WARNING: #{self.class}#read! will be removed in 0.3.6, use read instead"
+        read
+      end
     end
   end
 end

data/lib/ccp/kvs/tch.rb

@@ -7,10 +7,11 @@ module Ccp
       def set(k,v) ; W{ super }; end
       def del(k)   ; W{ super }; end
       def count    ; R{ super }; end
-      def read!    ; R{ super }; end
       def keys     ; R{ super }; end
       def first_key; R{ super }; end
       def first    ; R{ super }; end
+      def read     ; R{ super }; end
+      def write(h) ; W{ super }; end
     end
   end
 end

data/lib/ccp/kvs/tokyo/cabinet.rb

@@ -60,10 +60,10 @@ module Ccp
         ######################################################################
         ### bulk operations (not DRY but fast)
 
-        def read!
-          tryR("read!")
+        def read
+          tryR("read")
           hash = {}
-          @db.iterinit or tokyo_error!("read!: ")
+          @db.iterinit or tokyo_error!("read: ")
           while k = @db.iternext
             v = @db.get(k) or tokyo_error!("get(%s): " % k)
             hash[k] = decode(v)
@@ -71,6 +71,15 @@ module Ccp
           return hash
         end
 
+        def write(h)
+          tryW("write")
+          h.each_pair do |k,v|
+            val = encode(v)
+            @db[k.to_s] = val or tokyo_error!("write(%s): " % k)
+          end
+          return h
+        end
+
         ######################################################################
         ### iterator
 

data/lib/ccp/kvs/tokyo/state_machine.rb

@@ -11,20 +11,20 @@ module Ccp
         READABLE = 2
         WRITABLE = 3
 
+        LOCKED_BY = proc{|c| Array(c).select{|i| i !~ %r{/ruby/[^/]+/gems/}}[0,5].join("\n") || c rescue c}
+
         def state
           @state || CLOSED
         end
 
         def locker_info
-          pretty = proc{|c| Array(c).find{|i| i !~ %r{/ruby/[^/]+/gems/}} || c}
-
           if CONNECTIONS[@source]
-            return pretty[CONNECTIONS[@source]]
+            return LOCKED_BY[CONNECTIONS[@source]]
           end
 
           target = File.basename(@source)
           CONNECTIONS.each_pair do |file, reason|
-            return pretty[reason] if File.basename(file) == target
+            return LOCKED_BY[reason] if File.basename(file) == target
           end
 
           if CONNECTIONS.any?
@@ -34,67 +34,70 @@ module Ccp
           end
         end
 
-        def open(mode)
+        def open(mode, locker = nil)
           Pathname(@source.to_s).parent.mkpath
 
           # open and mark filename for threading error
           if @db.open(@source.to_s, mode)
-            CONNECTIONS[@db.path.to_s] = (caller rescue "???")
+            locker ||= (caller rescue "???")
+            STDERR.puts "LOCK: #{@source} by [#{LOCKED_BY[locker]}]" if @debug
+            CONNECTIONS[@db.path.to_s] = locker
           elsif threading_error?
-            raise Tokyo::Locked, "%s is locked by %s" % [@source, locker_info]
+            raise Tokyo::Locked, "%s is locked by [%s]" % [@source, locker_info]
           else
             tokyo_error!("%s#open(%s,%s): " % [self.class, @source, mode])
           end
         end
 
-        def __close__
+        def __close__(locker = nil)
           @db.close
           CONNECTIONS[@db.path] = nil
+          STDERR.puts "UNLOCK: #{@source} by [#{LOCKED_BY[locker || caller]}]" if @debug
         end
 
-        def close
-          C!
+        def close(locker = nil)
+          C!(locker)
         end
 
-        def C!
+        def C!(locker = nil)
           case state
           when CLOSED   ; # NOP
           when READABLE,
-               WRITABLE ; __close__; @state = CLOSED
+               WRITABLE ; __close__(locker); @state = CLOSED
           else          ; raise "unknown state: #{state}"
           end
         end
 
-        def R!
+        def R!(locker = nil)
           case state
-          when CLOSED   ; open(HDB::OREADER); @state = READABLE
+          when CLOSED   ; open(HDB::OREADER, locker); @state = READABLE
           when READABLE ; # NOP
           when WRITABLE ; # NOP
           else          ; raise "unknown state: #{state}"
           end
         end
 
-        def W!
+        def W!(locker = nil)
           case state
-          when CLOSED   ; open(HDB::OCREAT | HDB::OWRITER); @state = WRITABLE
-          when READABLE ; C!; W!()
+          when CLOSED   ; open(HDB::OCREAT | HDB::OWRITER, locker); @state = WRITABLE
+          when READABLE ; C!(locker); W!(locker)
           when WRITABLE ; # NOP
           else          ; raise "unknown state: #{state}"
           end
         end
 
-        def R(&block)
+        def R(locker = nil, &block)
           case state
-          when CLOSED   ; begin; R!(); yield; ensure; close; end
+          when CLOSED   ; begin; R!(locker); yield; ensure; close(locker); end
           when READABLE ; yield
           when WRITABLE ; yield
           else          ; raise "unknown state: #{state}"
           end
         end
 
-        def W(&block)
+        def W(locker = nil, &block)
           case state
-          when CLOSED   ; begin; W!(); yield; ensure; close; end
+          when CLOSED   ; begin; W!(locker); yield; ensure; close(locker); end
           when READABLE ; raise "reopen from read to write is not permitted"
             # TODO: close -> W -> close -> R ???
           when WRITABLE ; yield

data/lib/ccp/receivers/skippable.rb

@@ -2,7 +2,10 @@ module Ccp
   module Receivers
     module Skippable
       def execute(cmd)
-        return false if skip?(cmd)
+        if skip?(cmd)
+          notify_skip(cmd)
+          return false
+        end
         super
       end
 
@@ -11,6 +14,11 @@ module Ccp
           key = "skip_%s" % cmd.class.name.underscore.gsub("/","_")
           data.set?(key)
         end
+
+        def notify_skip(cmd)
+          @logger ||= data.set?(:logger) ? data[:logger] : Logger.new(STDOUT)
+          @logger.debug Utils::Colorize.pink("[SKIP] #{cmd.class}")
+        end
     end
   end
 end

data/lib/ccp/storage.rb

@@ -10,7 +10,7 @@ module Ccp
     end
 
     attr_reader :source, :kvs, :codec, :path
-    delegate :get, :set, :del, :keys, :read!, :to=>"@kvs"
+    delegate :get, :set, :del, :keys, :read, :to=>"@kvs"
 
     def initialize(source, kvs, codec)
       @source = source
@@ -43,20 +43,33 @@ module Ccp
       )
     end
 
+    def close
+      @tables.each_pair do |_,kvs|
+        kvs.close
+      end
+      @tables = {}
+    end
+
     ######################################################################
     ### kvs
 
-    def read!
+    def read
       if @path.directory?
         tables
         hash = {}
         @tables.each_pair do |k, kvs|
-          hash[k] = kvs.read!
+          hash[k] = kvs.read
         end
         return hash
       else
-        return @kvs.read!
+        return @kvs.read
       end
     end
+
+    # backward compat (until 0.3.6)
+    def read!
+      STDERR.puts "DEPRECATION WARNING: #{self.class}#read! will be removed in 0.3.6, use read instead"
+      read
+    end
   end
 end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.3.4"
+  VERSION = "0.3.5"
 end

data/spec/kvs/core_spec.rb

@@ -12,4 +12,6 @@ describe Ccp::Kvs::Core do
   it { should respond_to("touch") }
   it { should respond_to("exist?") }
   it { should respond_to("key?") }
+  it { should respond_to("read") }
+  it { should respond_to("write") }
 end

data/spec/kvs/kvs_spec.rb

@@ -72,13 +72,23 @@ Ccp::Kvs.each do |klass|
       end
     end
 
-    describe "#read!" do
+    describe "#read" do
       specify do
         kvs.touch
         kvs.codec! :json
         kvs.set(:a, 1)
         kvs.set(:b, ["x", 0])
-        kvs.read!.should == {"a"=>1, "b"=>["x", 0]}
+        kvs.read.should == {"a"=>1, "b"=>["x", 0]}
+      end
+    end
+
+    describe "#write" do
+      specify do
+        kvs.touch
+        kvs.codec! :json
+        kvs.write("a"=>1, "b"=>["x", 0])
+        kvs["a"].should == 1
+        kvs["b"].should == ["x", 0]
       end
     end
 

data/spec/kvs/tokyo/cabinet_spec.rb

@@ -206,15 +206,25 @@ describe Ccp::Kvs::Tokyo::Cabinet do
   end
 
   ######################################################################
-  ### read!
+  ### read / write
 
-  describe "#read!" do
+  describe "#read" do
     specify do
       put(:foo, 1)
       put(:bar, 2)
 
       kvs.R!
-      kvs.read!.should == {"foo" => "1", "bar" => "2"}
+      kvs.read.should == {"foo" => "1", "bar" => "2"}
+    end
+  end
+
+  describe "#write" do
+    specify do
+      kvs.W!
+      kvs.write("foo" => "1", "bar" => "2")
+
+      kvs.get("foo").should == "1"
+      kvs.get("bar").should == "2"
     end
   end
 

data/spec/storage/loadable_spec.rb

@@ -37,7 +37,7 @@ describe Ccp::Storage do
     end
   end
 
-  describe "#read!" do
+  describe "#read" do
     before { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
 
     context "(file)" do
@@ -50,7 +50,7 @@ describe Ccp::Storage do
         system("tchmgr put #{tch} b 0.1")
       }
       specify do
-        subject.read!.should == {"a" => [1, 2], "b" => 0.1}
+        subject.read.should == {"a" => [1, 2], "b" => 0.1}
       end
     end
     
@@ -66,13 +66,21 @@ describe Ccp::Storage do
         system("tchmgr put    #{tch}/b.json.tch y 0.1")
       }
       specify do
-        subject.read!.should == {
+        subject.read.should == {
           "a" => {"x" => [1, 2], "y" => []},
           "b" => {"y" => 0.1},
         }
       end
     end
+  end
+
+  describe "#close" do
+    before { FileUtils.rm_rf(tmp_path) if tmp_path.directory? }
 
+    let(:tch) { tmp_path + "foo.json.tch" }
+    subject { Ccp::Storage.new(tch, Ccp::Kvs::Tch, Ccp::Serializers::Json) }
+  
+    it { should respond_to(:close) }
   end
 
 #  it { should respond_to(:tables) }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 3
-  - 4
-  version: 0.3.4
+  - 5
+  version: 0.3.5
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-09-04 00:00:00 Z
+date: 2013-10-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport