ruote-redis 2.1.10 → 2.1.11

data/CHANGELOG.txt

@@ -2,6 +2,14 @@
 = ruote-redis - CHANGELOG.txt
 
 
+== ruote-redis 2.1.11    released 2010/10/01
+
+- storage format change (thanks @wwkeyboard)
+- get_many(type, keys) support (array of keys instead of lonely regex key)
+- get_many(type, nil, :skip => 10) support
+- get_many(type, nil, :count => true) support
+
+
 == ruote-redis 2.1.10    released 2010/06/15
 
 - works with redis-rb 1.0.2 and 2.0

data/CREDITS.txt

@@ -0,0 +1,18 @@
+
+= ruote-redis CREDITS.txt
+
+
+== authors
+
+- John Mettraux  http://jmettraux.wordpress.com
+
+
+== contributors
+
+- Aaron Lee - http://github.com/wwkeyboard
+
+
+== many thanks to
+
+- the Redis team for their great project
+

data/README.rdoc

@@ -38,13 +38,13 @@ start a redis server instance (port 6379) and then
 
 get into ruote/ and do
 
-  ruby test/unit/storage.rb --redis
+  ruby test/unit/storage.rb -- --redis
 
 * functional tests :
 
 get into ruote/ and do
 
-  ruby test/functional/test.rb --redis
+  ruby test/functional/test.rb -- --redis
 
 
 == license

data/Rakefile

@@ -33,7 +33,7 @@ Redis storage for ruote (a ruby workflow engine)
   #gem.test_file = 'test/test.rb'
 
   gem.add_dependency 'ruote', ">= #{Ruote::Redis::VERSION}"
-  gem.add_dependency 'redis', '>= 2.0.1'
+  gem.add_dependency 'redis', '>= 2.0.5'
   gem.add_development_dependency 'yard'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'jeweler'
@@ -46,33 +46,30 @@ Jeweler::GemcutterTasks.new
 #
 # DOC
 
-begin
-
-  require 'yard'
+#
+# make sure to have rdoc 2.5.x to run that
+#
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rd|
 
-  YARD::Rake::YardocTask.new do |doc|
-    doc.options = [
-      '-o', 'html/ruote-redis', '--title',
-      "ruote-redis #{Ruote::Redis::VERSION}"
-    ]
-  end
+  rd.main = 'README.rdoc'
+  rd.rdoc_dir = 'rdoc/ruote-redis_rdoc'
 
-rescue LoadError
+  rd.rdoc_files.include(
+    'README.rdoc', 'CHANGELOG.txt', 'CREDITS.txt', 'lib/**/*.rb')
 
-  task :yard do
-    abort "YARD is not available : sudo gem install yard"
-  end
+  rd.title = "ruote-redis #{Ruote::Redis::VERSION}"
 end
 
 
 #
 # TO THE WEB
 
-task :upload_website => [ :clean, :yard ] do
+task :upload_rdoc => [ :clean, :rdoc ] do
 
   account = 'jmettraux@rubyforge.org'
   webdir = '/var/www/gforge-projects/ruote'
 
-  sh "rsync -azv -e ssh html/ruote-redis #{account}:#{webdir}/"
+  sh "rsync -azv -e ssh rdoc/ruote-redis_rdoc #{account}:#{webdir}/"
 end
 

data/lib/ruote/redis/storage.rb

@@ -1,8 +1,8 @@
 #--
-# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+# Copyright(c) 2005-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
+# of this software and associated documentation files(the "Software"), to deal
 # in the Software without restriction, including without limitation the rights
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
@@ -37,8 +37,8 @@ module Redis
   # A Redis storage for ruote.
   #
   # The constructor accepts two arguments, the first one is a Redis instance
-  # ( see http://github.com/ezmobius/redis-rb ), the second one is the classic
-  # ruote engine options ( see
+  #( see http://github.com/ezmobius/redis-rb ), the second one is the classic
+  # ruote engine options( see
   # http://ruote.rubyforge.org/configuration.html#engine )
   #
   #   require 'redis' # gem install redis
@@ -66,12 +66,14 @@ module Redis
 
     attr_reader :redis
 
-    def initialize (redis, options={})
+    # A Redis storage for ruote.
+    #
+    def initialize(redis, options={})
 
       @redis = redis
       @options = options
 
-      def @redis.keys_to_a (opt)
+      def @redis.keys_to_a(opt)
         r = keys(opt)
         r.is_a?(Array) ? r : r.split(' ')
       end
@@ -79,132 +81,167 @@ module Redis
       put_configuration
     end
 
-    def reserve (doc)
+    def reserve(doc)
 
       @redis.del(key_for(doc))
     end
 
-    def put_msg (action, options)
+    def put_msg(action, options)
 
       doc = prepare_msg_doc(action, options)
 
+      puts "XXX" if @redis.nil?
+
       @redis.set(key_for(doc), to_json(doc))
 
       nil
     end
 
-    def put_schedule (flavour, owner_fei, s, msg)
+    def put_schedule(flavour, owner_fei, s, msg)
 
-      if doc = prepare_schedule_doc(flavour, owner_fei, s, msg)
-        @redis.set(key_for(doc), to_json(doc))
-        return doc['_id']
-      end
+      doc = prepare_schedule_doc(flavour, owner_fei, s, msg)
 
-      nil
+      return nil unless doc
+
+      @redis.set(key_for(doc), to_json(doc))
+
+      doc['_id']
     end
 
-    def delete_schedule (schedule_id)
+    def delete_schedule(schedule_id)
 
       @redis.del(key_for('schedules', schedule_id))
     end
 
-    def put (doc, opts={})
+    def put(doc, opts={})
 
-      rev = doc['_rev'].to_i
       key = key_for(doc)
+      rev = doc['_rev']
+
+      lock(key) do
+
+        current_doc = do_get(key)
+        current_rev = current_doc ? current_doc['_rev'] : nil
+
+        if current_rev && rev != current_rev
+          #
+          # version in storage is newer than version being put,
+          # (eturn version in storage)
+          #
+          current_doc
+
+        elsif rev && current_rev.nil?
+          #
+          # document deleted, put fails (return true)
+          #
+          true
+
+        else
+          #
+          # put is successful (return nil)
+          #
+          nrev = (rev.to_i + 1).to_s
+          @redis.set(key, to_json(doc.merge('_rev' => nrev)))
+          doc['_rev'] = nrev if opts[:update_rev]
+
+          nil
+        end
+      end
+    end
 
-      current_rev = @redis.get(key).to_i
+    def get(type, key)
 
-      return true if current_rev == 0 && rev > 0
-      return do_get(doc, current_rev) if rev != current_rev
+      do_get(key_for(type, key))
+    end
 
-      nrev = rev + 1
+    def delete(doc)
 
-      # the setnx here is crucial in multiple workers env...
+      rev = doc['_rev']
 
-      r = @redis.setnx(
-        key_rev_for(doc, nrev),
-        to_json(doc.merge('_rev' => nrev), opts))
+      raise ArgumentError.new("can't delete doc without _rev") unless rev
 
-      return get(doc['type'], doc['_id']) if r == false
+      key = key_for(doc)
 
-      @redis.set(key, nrev)
-      @redis.del(key_rev_for(doc, rev)) if rev > 0
+      lock(key) do
 
-      doc['_rev'] = nrev if opts[:update_rev]
+        current_doc = do_get(key)
 
-      nil
-    end
+        if current_doc.nil?
+          #
+          # document is [already] gone, delete fails (return true)
+          #
+          true
 
-    def get (type, key)
+        elsif current_doc['_rev'] != rev
+          #
+          # version in storage doesn't match version to delete
+          # (return version in storage)
+          #
+          current_doc
 
-      do_get(type, key, @redis.get(key_for(type, key)))
-    end
+        else
+          #
+          # delete is successful (return nil)
+          #
+          @redis.del(key)
 
-    def delete (doc)
-
-      raise ArgumentError.new(
-        "can't delete doc without _rev") unless doc['_rev']
-
-      r = put(doc, :delete => true)
+          nil
+        end
+      end
+    end
 
-      return r if r != nil
+    def get_many(type, key=nil, opts={})
 
-      @redis.keys_to_a("#{key_for(doc)}*").sort.each { |k|
-        Thread.pass # lingering a bit...
-        @redis.del(k)
-      }
-        # deleting the key_rev last and making 1 'keys' call preliminarily
+      keys = key ? Array(key) : nil
 
-      nil
-    end
+      #ids = if type == 'msgs' || type == 'schedules'
+      #  @redis.keys_to_a("#{type}/*")
 
-    def get_many (type, key=nil, opts={})
+      ids = if keys == nil
 
-      keys = "#{type}/*"
+        @redis.keys_to_a("#{type}/*")
 
-      ids = if type == 'msgs' || type == 'schedules'
+      elsif keys.first.is_a?(String)
 
-        @redis.keys_to_a(keys)
+        keys.collect { |k| @redis.keys_to_a("#{type}/*!#{k}") }.flatten
 
-      else
+      else #if keys.first.is_a?(Regexp)
 
-        @redis.keys_to_a(keys).inject({}) { |h, k|
+        @redis.keys_to_a("#{type}/*").select { |i|
 
-          if m = k.match(/^[^\/]+\/([^\/]+)\/(\d+)$/)
+          i = i[type.length + 1..-1]
+            # removing "^type/"
 
-            if ( ! key) || m[1].match(key)
+          keys.find { |k| k.match(i) }
+        }
+      end
 
-              o = h[m[1]]
-              n = [ m[2].to_i, k ]
-              h[m[1]] = [ m[2].to_i, k ] if ( ! o) || o.first < n.first
-            end
-          end
+      ids = ids.reject { |i| i.match(LOCK_KEY) }
+      ids = ids.sort
+      ids = ids.reverse if opts[:descending]
 
-          h
-        }.values.collect { |i| i[1] }
-      end
+      skip = opts[:skip] || 0
+      limit = opts[:limit] || ids.length
+      ids = ids[skip, limit]
 
-      if l = opts[:limit]
-        ids = ids[0, l]
+      docs = ids.length > 0 ? @redis.mget(*ids) : []
+      docs = docs.inject({}) do |h, doc|
+        if doc
+          doc = Rufus::Json.decode(doc)
+          h[doc['_id']] = doc
+        end
+        h
       end
 
-      ids.inject([]) do |a, i|
-        v = @redis.get(i)
-        a << Rufus::Json.decode(v) if v
-        a
-      end
+      opts[:count] ? docs.size : docs.values
     end
 
-    def ids (type)
-
-      @redis.keys_to_a("#{type}/*").inject([]) { |a, k|
-
-        if m = k.match(/^[^\/]+\/([^\/]+)$/)
-          a << m[1]
-        end
+    def ids(type)
 
-        a
+      @redis.keys_to_a("#{type}/*").reject { |i|
+        i.match(LOCK_KEY)
+      }.collect { |i|
+        i.split('/').last
       }.sort
     end
 
@@ -213,77 +250,100 @@ module Redis
       @redis.keys_to_a('*').each { |k| @redis.del(k) }
     end
 
-    #def dump (type)
-    #  @dbs[type].dump
-    #end
+    # Returns a String containing a representation of the current content of
+    # in this Redis storage.
+    #
+    def dump(type)
+
+      @redis.keys_to_a("#{type}/*").sort.join("\n")
+    end
+
+    def close
 
-    def shutdown
+      @redis.quit
     end
 
     # Mainly used by ruote's test/unit/ut_17_storage.rb
     #
-    def add_type (type)
+    def add_type(type)
     end
 
-    # Nukes a db type and reputs it (losing all the documents that were in it).
+    # Nukes a db type and reputs it(losing all the documents that were in it).
     #
-    def purge_type! (type)
+    def purge_type!(type)
 
       @redis.keys_to_a("#{type}/*").each { |k| @redis.del(k) }
     end
 
     protected
 
-    #   key_for(doc)
-    #   key_for(type, key)
+    LOCK_KEY = /-lock$/
+
+    # A locking mecha.
+    #
+    # Mostly inspired from http://code.google.com/p/redis/wiki/SetnxCommand
     #
-    def key_for (*args)
+    def lock(key, &block)
 
-      a = args.first
+      kl = "#{key}-lock"
 
-      (a.is_a?(Hash) ? [ a['type'], a['_id'] ] : args[0, 2]).join('/')
-    end
+      loop do
 
-    #   key_rev_for(doc)
-    #   key_rev_for(doc, rev)
-    #   key_rev_for(type, key, rev)
-    #
-    def key_rev_for (*args)
+        r = @redis.setnx(kl, Time.now.to_f.to_s)
 
-      as = nil
-      a = args.first
+        if r == false
+
+          t = @redis.get(kl)
+
+          @redis.del(kl) if t && Time.now.to_f - t.to_f > 60.0
+            # after 1 minute, locks time out
+
+          sleep 0.007 # let's try to lock again after a while
+        else
 
-      if a.is_a?(Hash)
-        as = [ a['type'], a['_id'], a['_rev'] ] if a.is_a?(Hash)
-        as[2] = args[1] if args[1]
-      else
-        as = args[0, 3]
+          break # lock acquired
+        end
       end
 
-      as.join('/')
+      #@redis.expire(kl, 2)
+        # this doesn't work, it makes the next call to setnx succeed
+
+      result = block.call
+
+      @redis.del(kl)
+
+      result
     end
 
-    def do_get (*args)
+    #   key_for(doc)
+    #   key_for(type, key)
+    #
+    def key_for(*args)
+
+      a = args.first
+
+     (a.is_a?(Hash) ? [ a['type'], a['_id'] ] : args[0, 2]).join('/')
+    end
 
-      d = @redis.get(key_rev_for(*args))
+    def do_get(key)
 
-      d ? Rufus::Json.decode(d) : nil
+      from_json(@redis.get(key))
     end
 
-    def to_json (doc, opts={})
+    def from_json(s)
 
-      doc = if opts[:delete]
-        nil
-      else
-        doc.merge('put_at' => Ruote.now_to_utc_s)
-      end
+      s ? Rufus::Json.decode(s) : nil
+    end
+
+    def to_json(doc, opts={})
 
-      Rufus::Json.encode(doc)
+      Rufus::Json.encode(
+        opts[:delete] ? nil : doc.merge('put_at' => Ruote.now_to_utc_s))
     end
 
     # Don't put configuration if it's already in
     #
-    # (avoid storages from trashing configuration...)
+    # (prevent storages from trashing configuration...)
     #
     def put_configuration
 

data/lib/ruote/redis/version.rb

@@ -1,7 +1,7 @@
 
 module Ruote
 module Redis
-  VERSION = '2.1.10'
+  VERSION = '2.1.11'
 end
 end
 

data/ruote-redis.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ruote-redis}
-  s.version = "2.1.10"
+  s.version = "2.1.11"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Mettraux"]
-  s.date = %q{2010-06-15}
+  s.date = %q{2010-10-01}
   s.description = %q{Redis storage for ruote (a ruby workflow engine)}
   s.email = %q{jmettraux@gmail.com}
   s.extra_rdoc_files = [
@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     "CHANGELOG.txt",
+     "CREDITS.txt",
      "LICENSE.txt",
      "README.rdoc",
      "Rakefile",
@@ -44,21 +45,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ruote>, [">= 2.1.10"])
-      s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
+      s.add_runtime_dependency(%q<ruote>, [">= 2.1.11"])
+      s.add_runtime_dependency(%q<redis>, [">= 2.0.5"])
       s.add_development_dependency(%q<yard>, [">= 0"])
       s.add_development_dependency(%q<rake>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
     else
-      s.add_dependency(%q<ruote>, [">= 2.1.10"])
-      s.add_dependency(%q<redis>, [">= 2.0.1"])
+      s.add_dependency(%q<ruote>, [">= 2.1.11"])
+      s.add_dependency(%q<redis>, [">= 2.0.5"])
       s.add_dependency(%q<yard>, [">= 0"])
       s.add_dependency(%q<rake>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
     end
   else
-    s.add_dependency(%q<ruote>, [">= 2.1.10"])
-    s.add_dependency(%q<redis>, [">= 2.0.1"])
+    s.add_dependency(%q<ruote>, [">= 2.1.11"])
+    s.add_dependency(%q<redis>, [">= 2.0.5"])
     s.add_dependency(%q<yard>, [">= 0"])
     s.add_dependency(%q<rake>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 1
-  - 10
-  version: 2.1.10
+  - 11
+  version: 2.1.11
 platform: ruby
 authors: 
 - John Mettraux
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-15 00:00:00 +09:00
+date: 2010-10-01 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,8 +27,8 @@ dependencies:
         segments: 
         - 2
         - 1
-        - 10
-        version: 2.1.10
+        - 11
+        version: 2.1.11
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -41,8 +41,8 @@ dependencies:
         segments: 
         - 2
         - 0
-        - 1
-        version: 2.0.1
+        - 5
+        version: 2.0.5
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -92,6 +92,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - CHANGELOG.txt
+- CREDITS.txt
 - LICENSE.txt
 - README.rdoc
 - Rakefile