ccp 0.2.8 → 0.2.9

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 tmp/*
+vendor

data/ccp.gemspec

@@ -18,9 +18,19 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  if RUBY_VERSION >= "1.9"
+    s.add_dependency "activesupport"
+  else
+    s.add_dependency "activesupport", "~> 3.2.0"
+  end
+
   s.add_dependency "typed", ">= 0.2.2"
-  s.add_dependency "must", ">= 0.2.7"
+  s.add_dependency "must", ">= 0.2.9"
   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_development_dependency "rspec"
 end

data/lib/ccp.rb

@@ -14,4 +14,5 @@ module Ccp
   autoload :Receivers,         'ccp/receivers'
   autoload :Persistent,        'ccp/persistent'
   autoload :Serializers,       'ccp/serializers'
+  autoload :Kvs,               'ccp/kvs'
 end

data/lib/ccp/commands/resolvable.rb

@@ -2,9 +2,8 @@ module Ccp
   module Commands
     module Resolvable
       def resolve(klass)
-        klass.must.coerced(Class, Module) {
+        klass.is_a?(Class) or
           raise CommandNotFound, "expected Class or Module, but got #{klass.class}"
-        }
 
         if klass.ancestors.include?(Commands::Core)
           return klass # ok

data/lib/ccp/kvs.rb

@@ -0,0 +1,46 @@
+require 'ccp/kvs/core'
+
+module Ccp
+  module Kvs
+    Error        = Class.new(RuntimeError)
+    NotFound     = Class.new(Error)
+    NotConnected = Class.new(Error)
+    NotAllowed   = Class.new(Error)
+    IOError      = Class.new(Error)
+
+    DICTIONARY = {}             # cache for (extname -> Kvs)
+
+    include Enumerable
+    delegate :delete, :to=>"DICTIONARY"
+
+    def each(&block)
+      DICTIONARY.each_value(&block)
+    end
+
+    def [](name)
+      kvs = DICTIONARY[name.to_s] and return kvs
+      name.must(Core) {
+        raise NotFound, "%s(%s) for %s" % [name, name.class, DICTIONARY.keys.inspect]
+      }
+    end
+
+    def []=(key, val)
+      DICTIONARY[key.to_s] = val
+    end
+
+    def <<(kvs)
+      kvs.must(Core)
+      self[kvs.ext] = kvs
+    end
+
+    alias :lookup :[]
+    extend self
+  end
+end
+
+require 'ccp/kvs/hash'
+require 'ccp/kvs/tokyo'
+require 'ccp/kvs/tch'
+
+Ccp::Kvs << Ccp::Kvs::Hash
+Ccp::Kvs << Ccp::Kvs::Tch

data/lib/ccp/kvs/core.rb

@@ -0,0 +1,28 @@
+module Ccp
+  module Kvs
+    module Core
+      def get(k)   ; raise NotImplementedError, "subclass resposibility"; end
+      def set(k,v) ; raise NotImplementedError, "subclass resposibility"; end
+      def del(k)   ; raise NotImplementedError, "subclass resposibility"; end
+
+      def open(*)  ; end
+      def close    ; end
+      def source   ; @source; end
+      def count    ; end
+      def touch    ; end
+
+      def [](k)    ; get(k)   ; end
+      def []=(k,v) ; set(k,v) ; end
+      def put(k,v) ; set(k,v) ; end
+      def out(k)   ; del(k)   ; end
+
+      def ext; self.class.name.split(/::/).last.to_s.downcase; end
+      def self.included(klass)
+        klass.class_eval do
+          def self.ext; name.split(/::/).last.to_s.downcase; end
+          def self.open(*args); new.tap{|kvs| kvs.open(*args)}; end
+        end
+      end
+    end
+  end
+end

data/lib/ccp/kvs/hash.rb

@@ -0,0 +1,16 @@
+module Ccp
+  module Kvs
+    class Hash
+      include Core
+
+      def initialize
+        @db = {}
+      end
+
+      def get(k)   ; @db[k.to_s]          ; end
+      def set(k,v) ; @db[k.to_s] = v.to_s ; end
+      def del(k)   ; @db.delete(k.to_s)   ; end
+      def count    ; @db.size             ; end
+    end
+  end
+end

data/lib/ccp/kvs/tch.rb

@@ -0,0 +1,12 @@
+require 'tokyocabinet'
+
+module Ccp
+  module Kvs
+    class Tch < Tokyo::Cabinet
+      def get(k)   ; R{ super }; end
+      def set(k,v) ; W{ super }; end
+      def del(k)   ; W{ super }; end
+      def count    ; R{ super }; end
+    end
+  end
+end

data/lib/ccp/kvs/tokyo.rb

@@ -0,0 +1,15 @@
+require 'tokyocabinet'
+
+module Ccp
+  module Kvs
+    module Tokyo
+      Error = Class.new(Ccp::Kvs::Error)
+    end
+  end
+end
+
+require 'ccp/kvs/tokyo/info'
+require 'ccp/kvs/tokyo/base'
+require 'ccp/kvs/tokyo/state_machine'
+require 'ccp/kvs/tokyo/cabinet'
+

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

@@ -0,0 +1,49 @@
+module Ccp
+  module Kvs
+    module Tokyo
+      class Base
+        include Ccp::Kvs::Core
+        include TokyoCabinet
+
+        ######################################################################
+        ### info
+
+        def info
+          if path.exist?
+            Tokyo::Info.parse(`tcamgr inform #{path}`)
+          else
+            raise Ccp::Kvs::NotConnected, "%s(%s)" % [ self.class, @source]
+          end
+        end
+
+        ######################################################################
+        ### kvs
+
+        def get(k)   ; @db[k]        ; end
+        def set(k,v) ; @db[k] = v    ; end
+        def del(k)   ; @db.delete(k) ; end
+
+        def path
+          file = @source.to_s.sub(/#.*$/, '') # parse "foo.tch#mode=r"
+          Pathname(file)
+        end
+
+        private
+          def tokyo_error!(label = nil)
+            raise Ccp::Kvs::Tokyo::Error, "%s%s" % [label, error_message]
+          end
+
+          def error_message
+            if @db
+              # TODO: Where is adb_errmsg?
+              "%s (%s)" % [@db.errmsg(@db.ecode).to_s, @db.ecode]
+            else
+              '[Not Initialized]'
+            end
+          rescue Exception => e
+            "[BUG] #{e}"
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Ccp
+  module Kvs
+    module Tokyo
+      class Cabinet < Base
+        include StateMachine
+
+        def initialize(source)
+          @source = source
+          @db     = HDB.new
+        end
+
+        ######################################################################
+        ### kvs
+
+        def get(k)
+          tryR("get")
+          v = @db[k.to_s]
+          if v
+            return v
+          else
+            if @db.ecode == HDB::ENOREC
+              return nil
+            else
+              tokyo_error!("get(%s): " % k)
+            end
+          end
+        end
+
+        def set(k,v)
+          tryW("set")
+          @db[k.to_s] = v.to_s or tokyo_error!("set(%s): " % k)
+        end
+
+        def del(k)
+          tryW("del")
+          v = get(k)
+          if v
+            if @db.delete(k.to_s) 
+              return v
+            else
+              tokyo_error!("del(%s): " % k)
+            end
+          else
+            return nil
+          end
+        end
+
+        def count
+          tryR("count")
+          return @db.rnum
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Ccp
+  module Kvs
+    module Tokyo
+      class Info
+        ######################################################################
+        ### API
+
+        dsl_accessor :path         , "to_s"
+        dsl_accessor :database_type, "to_s"
+        dsl_accessor :record_number, "to_i"
+        dsl_accessor :size         , "to_i"
+
+        def count; record_number; end
+
+        ######################################################################
+        ### example
+        
+        def self.example
+          parse(<<-EOF)
+      path: /tmp/tc/foo.tch
+      database type: hash database
+      record number: 0
+      size: 528704
+          EOF
+        end
+
+        ######################################################################
+        ### parse
+        
+        def self.parse(buf)
+          # % tcamgr inform /tmp/tc/foo.tch
+          #
+          # path: /tmp/tc/foo.tch
+          # database type: hash database
+          # record number: 0
+          # size: 528704
+          #
+
+          info = new
+          buf.scan(/^([a-z ]+): (.*?)($|\Z)/mo).each do |key, val|
+            key = key.strip.tr(' ', '_')
+            val = val.strip
+            info[key] = val
+          end
+          return info
+        end
+
+        ######################################################################
+        ### instance methods
+        
+        def initialize
+          @hash = {}
+        end
+
+        def [](key)
+          @hash[key]
+        end
+
+        def []=(key, val)
+          @hash[key] = val
+        end
+
+        private
+          def method_missing(key, *args, &block)
+            raise unless args.empty?
+            raise unless self.class.respond_to?(key)
+
+            cast = self.class.__send__(key)
+            return self[key.to_s].__send__(cast)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Ccp
+  module Kvs
+    module Tokyo
+      module StateMachine
+        include TokyoCabinet
+
+        ######################################################################
+        ### state machine
+
+        CLOSED   = 1
+        READABLE = 2
+        WRITABLE = 3
+
+        def state
+          @state || CLOSED
+        end
+
+        def open(mode)
+          Pathname(@source.to_s).parent.mkpath
+          @db.open(@source.to_s, mode) or tokyo_error!("%s#open(%s,%s): " % [self.class, @source, mode])
+        end
+
+        def close
+          C!
+        end
+
+        def C!
+          case state
+          when CLOSED   ; # NOP
+          when READABLE,
+               WRITABLE ; @db.close; @state = CLOSED
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def R!
+          case state
+          when CLOSED   ; open(HDB::OREADER); @state = READABLE
+          when READABLE ; # NOP
+          when WRITABLE ; # NOP
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def W!
+          case state
+          when CLOSED   ; open(HDB::OCREAT | HDB::OWRITER); @state = WRITABLE
+          when READABLE ; C!; W!()
+          when WRITABLE ; # NOP
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def R(&block)
+          case state
+          when CLOSED   ; begin; R!(); yield; ensure; close; end
+          when READABLE ; yield
+          when WRITABLE ; yield
+          else          ; raise "unknown state: #{state}"
+          end
+        end
+
+        def W(&block)
+          case state
+          when CLOSED   ; begin; W!(); yield; ensure; close; end
+          when READABLE ; raise "reopen from read to write is not permitted"
+          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