ccp 0.3.5 → 0.4.0

data/ccp.gemspec

@@ -20,18 +20,19 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   if RUBY_VERSION >= "1.9"
-    s.add_dependency "activesupport"
+    s.add_runtime_dependency "activesupport"
   else
-    s.add_dependency "activesupport", "~> 3.2.0"
+    s.add_runtime_dependency "activesupport", "~> 3.2.0"
   end
 
-  s.add_dependency "typed", ">= 0.2.2"
-  s.add_dependency "must", ">= 0.3.0"
-  s.add_dependency "dsl_accessor", ">= 0.4.1"
-  s.add_dependency "json"
-  s.add_dependency "yajl-ruby"
-  s.add_dependency "msgpack", "> 0.4"
-  s.add_dependency "tokyocabinet", "~> 1.29.1"
+  s.add_runtime_dependency "typed", ">= 0.2.2"
+  s.add_runtime_dependency "must", ">= 0.3.0"
+  s.add_runtime_dependency "dsl_accessor", ">= 0.4.1"
+  s.add_runtime_dependency "json"
+  s.add_runtime_dependency "yajl-ruby"
+  s.add_runtime_dependency "msgpack", "> 0.4"
 
   s.add_development_dependency "rspec"
+  s.add_development_dependency "tokyocabinet", "~> 1.29.1"
+  s.add_development_dependency "kyotocabinet-ruby", "~> 1.27.1"
 end

data/lib/ccp/kvs.rb

@@ -10,6 +10,14 @@ module Ccp
 
     DICTIONARY = {}             # cache for (extname -> Kvs)
 
+    def self.load(path)
+      array = path.to_s.split(".")
+      kvs   = Ccp::Kvs[array.pop].new(path)
+      codec = Ccp::Serializers[array.pop]
+      kvs.codec!(codec)
+      return kvs
+    end
+
     include Enumerable
     delegate :delete, :to=>"DICTIONARY"
 
@@ -39,8 +47,6 @@ module Ccp
 end
 
 require 'ccp/kvs/hash'
-require 'ccp/kvs/tokyo'
 require 'ccp/kvs/tch'
+require 'ccp/kvs/kch'
 
-Ccp::Kvs << Ccp::Kvs::Hash
-Ccp::Kvs << Ccp::Kvs::Tch

data/lib/ccp/kvs/core.rb

@@ -35,12 +35,6 @@ module Ccp
       # 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/hash.rb

@@ -16,3 +16,5 @@ module Ccp
     end
   end
 end
+
+Ccp::Kvs << Ccp::Kvs::Hash

data/lib/ccp/kvs/kch.rb

@@ -0,0 +1,33 @@
+begin
+  require 'kyotocabinet'
+rescue LoadError
+  load_error = true
+end
+
+unless load_error
+  require 'ccp/kvs/kyoto'
+
+  module Ccp
+    module Kvs
+      class Kch < Kyoto::Cabinet
+        # core
+        def get(k)        ; R{ super }; end
+        def set(k,v)      ; W{ super }; end
+        def del(k)        ; W{ super }; end
+        def count         ; R{ super }; end
+        def read          ; R{ super }; end
+        def write(h)      ; W{ super }; end
+
+        # enum
+        def each(&b)      ; R{ super }; end
+        def each_pair(&b) ; R{ super }; end
+        def each_key(&b)  ; R{ super }; end
+        def keys          ; R{ super }; end
+        def first_key     ; R{ super }; end
+        def first         ; R{ super }; end
+      end
+    end
+  end
+
+  Ccp::Kvs << Ccp::Kvs::Kch
+end

data/lib/ccp/kvs/kyoto.rb

@@ -0,0 +1,17 @@
+require 'kyotocabinet'
+
+module Ccp
+  module Kvs
+    module Kyoto
+      Error  = Class.new(Ccp::Kvs::Error)
+      Locked = Class.new(Error)
+
+      CONNECTIONS = {}
+    end
+  end
+end
+
+require 'ccp/kvs/kyoto/base'
+require 'ccp/kvs/kyoto/state_machine'
+require 'ccp/kvs/kyoto/cabinet'
+

data/lib/ccp/kvs/kyoto/base.rb

@@ -0,0 +1,60 @@
+module Ccp
+  module Kvs
+    module Kyoto
+      class Base
+        include Ccp::Kvs::Core
+        include KyotoCabinet
+
+        ######################################################################
+        ### info
+
+        def info
+          raise "not implemented yet"
+        end
+
+        ######################################################################
+        ### kvs
+
+        def path
+          file = @source.to_s.sub(/#.*$/, '') # parse "foo.tch#mode=r"
+          Pathname(file)
+        end
+
+        private
+          # Check ecode and then raise. too boring... The library should implement this as atomic operation!
+          def atomic(&block)
+            raise NotImplementedError, "tc keep ecode until new erros occured"
+
+            if kyoto_error?
+              raise "tc already error before atomic: #{@db.ecode}"
+            end
+            v = block.call
+            kyoto_error! if kyoto_error?
+            return v
+          end
+
+          def kyoto_error!(label = nil)
+            raise Ccp::Kvs::Kyoto::Error, "%s%s (%s)" % [label, error_message, @source]
+          end
+
+          def kyoto_error?
+            @db.error.is_a?(KyotoCabinet::Error::XSUCCESS)
+          end
+
+          def threading_error?
+            false
+          end
+
+          def error_message
+            if @db
+              @db.error
+            else
+              '[Not Initialized]'
+            end
+          rescue Exception => e
+            "[BUG] #{e}"
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module Ccp
+  module Kvs
+    module Kyoto
+      class Cabinet < Base
+        include StateMachine
+
+        def initialize(source)
+          @source = source
+          @db     = DB.new
+        end
+
+        ######################################################################
+        ### kvs
+
+        def get(k)
+          tryR("get")
+          v = @db[k.to_s]
+          if v
+            return decode(v)
+          else
+            if @db.error.is_a?(KyotoCabinet::Error::XNOREC)
+              return nil
+            else
+              kyoto_error!("get(%s): " % k)
+            end
+          end
+        end
+
+        def set(k,v)
+          tryW("set")
+          val = encode(v)
+          @db[k.to_s] = val or
+            kyoto_error!("set(%s): " % k)
+        end
+
+        def del(k)
+          tryW("del")
+          v = @db[k.to_s]
+          if v
+            if @db.delete(k.to_s)
+              return decode(v)
+            else
+              kyoto_error!("del(%s): " % k)
+            end
+          else
+            return nil
+          end
+        end
+
+        def exist?(k)
+          tryR("exist?")
+          return !! @db[k.to_s] # TODO: fast access
+        end
+
+        def count
+          tryR("count")
+          return @db.count
+        end
+
+        ######################################################################
+        ### bulk operations (not DRY but fast)
+
+        def read
+          tryR("read")
+          hash = {}
+          @db.each do |k, v|
+            v or kyoto_error!("each(%s): " % k)
+            hash[k] = decode(v)
+          end
+          return hash
+        end
+
+        def write(h)
+          tryW("write")
+          h.each_pair do |k,v|
+            val = encode(v)
+            @db[k.to_s] = val or kyoto_error!("write(%s): " % k)
+          end
+          return h
+        end
+
+        ######################################################################
+        ### iterator
+
+        def each(&block)
+          each_pair(&block)
+        end
+
+        def each_pair(&block)
+          tryR("each_pair")
+
+          # TODO: Waste memory! But kc ignores exceptions in his each block.
+          array = []
+          @db.each{|k, v| array << [k, decode(v)]} or kyoto_error!("each_pair: ")
+          array.each do |a|
+            block.call(a[0], a[1])
+          end
+        end
+
+        def each_key(&block)
+          tryR("each_key")
+
+          # TODO: Waste memory! But kc ignores exceptions in his each block.
+          array = []
+          @db.each_key{|k| array << k.first} or kyoto_error!("each_key: ")
+          array.each do |k|
+            block.call(k)
+          end
+        end
+
+        def keys
+          tryR("keys")
+
+          array = []
+          each_key do |key|
+            array << key
+          end
+          return array
+        end
+
+        def first_key
+          first.first
+        end
+
+        def first
+          tryR("first")
+          @db.cursor_process {|cur|
+            cur.jump
+            k, v = cur.get(true)
+            return [k, decode(v)]
+          }
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+module Ccp
+  module Kvs
+    module Kyoto
+      module StateMachine
+        include KyotoCabinet
+
+        ######################################################################
+        ### state machine
+
+        CLOSED   = 1
+        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
+          if CONNECTIONS[@source]
+            return LOCKED_BY[CONNECTIONS[@source]]
+          end
+
+          target = File.basename(@source)
+          CONNECTIONS.each_pair do |file, reason|
+            return LOCKED_BY[reason] if File.basename(file) == target
+          end
+
+          if CONNECTIONS.any?
+            return CONNECTIONS.inspect
+          else
+            return 'no brockers. maybe locked by other systems?'
+          end
+        end
+
+        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)
+            locker ||= (caller rescue "???")
+            STDERR.puts "LOCK: #{@source} by [#{LOCKED_BY[locker]}]" if @debug
+            CONNECTIONS[@db.path.to_s] = locker
+          elsif threading_error?
+            raise Kyoto::Locked, "%s is locked by [%s]" % [@source, locker_info]
+          else
+            kyoto_error!("%s#open(%s,%s): " % [self.class, @source, mode])
+          end
+        end
+
+        def __close__(locker = nil)
+          @db.close
+          CONNECTIONS[@db.path] = nil
+          STDERR.puts "UNLOCK: #{@source} by [#{LOCKED_BY[locker || caller]}]" if @debug
+        end
+
+        def close(locker = nil)
+          C!(locker)
+        end
+
+        def C!(locker = nil)
+          case state
+          when CLOSED   ; # NOP
+          when READABLE,
+               WRITABLE ; __close__(locker); @state = CLOSED
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def R!(locker = nil)
+          case state
+          when CLOSED   ; open(DB::OREADER, locker); @state = READABLE
+          when READABLE ; # NOP
+          when WRITABLE ; # NOP
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def W!(locker = nil)
+          case state
+          when CLOSED   ; open(DB::OCREATE | DB::OWRITER, locker); @state = WRITABLE
+          when READABLE ; C!(locker); W!(locker)
+          when WRITABLE ; # NOP
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def R(locker = nil, &block)
+          case state
+          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(locker = nil, &block)
+          case state
+          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
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def touch
+          W() {}
+        end
+
+        private
+          def isReadable
+            case state
+            when CLOSED   ; false
+            when READABLE ; true
+            when WRITABLE ; true
+            else          ; raise "unknown state: #{state}"
+            end
+          end
+
+          def isWritable
+            case state
+            when CLOSED   ; false
+            when READABLE ; false
+            when WRITABLE ; true
+            else          ; raise "unknown state: #{state}"
+            end
+          end
+
+          def tryR(op)
+            isReadable or raise NotAllowed, "use R! or R{tch.%s} (%s)" % [op, source]
+          end
+
+          def tryW(op)
+            isWritable or raise NotAllowed, "use W! or W{tch.%s} (%s)" % [op, source]
+          end
+        
+      end
+    end
+  end
+end