quetzall-cloud_cache 1.1.6 → 1.2.0

data/lib/cloud_cache.rb

@@ -54,6 +54,7 @@ module ActiveSupport
                 if (http_method == :put)
                     req = Net::HTTP::Put.new(uri.path)
                     req.body = body unless body.nil?
+                    #puts 'BODY SIZE=' + req.body.length.to_s
                 elsif (http_method == :post)
                     req = Net::HTTP::Post.new(uri.path)
                     if !parameters.nil?
@@ -66,6 +67,9 @@ module ActiveSupport
                     end
                 else
                     req = Net::HTTP::Get.new(uri.path)
+                    if !parameters.nil?
+                        req.set_form_data(parameters)
+                    end
                 end
                 headers.each_pair do |k, v|
                     req[k] = v
@@ -93,7 +97,9 @@ module ActiveSupport
                 run_http(:get, command_name, command_path)
             end
 
-            def put(key, val, seconds_to_store=0, raw=false)
+            def put(key, val, options={})
+                seconds_to_store = options[:expires_in] || options[:ttl]
+                raw = options[:raw]
                 #puts 'putting ' + val.to_s + ' to key=' + key
                 seconds_to_store = 0 if seconds_to_store.nil?
                 if raw
@@ -106,9 +112,9 @@ module ActiveSupport
                 run_http(:put, "PUT", key, data, nil, extra_headers)
             end
 
-
-            def get_multi(keys, raw=false)
+            def get_multi(keys, options={})
                 return {} if keys.size == 0
+                raw = options[:raw]
                 kj = keys.to_json
                 #puts "keys.to_json = " + kj
                 extra_headers = {"keys" => kj }
@@ -155,7 +161,8 @@ module ActiveSupport
                 values
             end
 
-            def get(key, raw=false)
+            def get(key, options={})
+                raw = options[:raw]
                 begin
                     data = run_http(:get, "GET", key)
                 rescue Net::HTTPServerException
@@ -173,7 +180,7 @@ module ActiveSupport
 
             # returns the value as an int.
             def get_i(key)
-                val = get(key, true)
+                val = get(key, :raw=>true)
                 return nil if val.nil?
                 return val.to_i
             end
@@ -213,12 +220,23 @@ module ActiveSupport
 
             def write(name, value, options={})
                 super
-                put(name, value, options[:expires_in], options[:raw])
+                put(name, value, options)
             end
 
             def delete(name, options = nil)
                 super
-                run_http(:delete, "DELETE", name)
+                begin
+                    run_http(:delete, "DELETE", name)
+                rescue Net::HTTPServerException => ex
+                    puts 'CAUGHT ' + ex.response.inspect
+                    case ex.response
+                        when Net::HTTPNotFound
+                            return false
+                        else
+                            raise ex
+                    end
+                end
+                true
             end
 
             def remove(name, options=nil)
@@ -235,7 +253,7 @@ module ActiveSupport
             end
 
             def exists?(key, options = nil)
-                x = get(key, true)
+                x = get(key, :raw=>true)
                 return !x.nil?
             end
 
@@ -247,13 +265,21 @@ module ActiveSupport
                 v
             end
 
-            def increment(key, val=1)
-                ret = run_http(:post, "POST", key + "/incr", nil, {"val"=>val})
+            def increment(key, val=1, options={})
+                headers = {"val"=>val}
+                if options[:set_if_not_found]
+                    headers["x-cc-set-if-not-found"] = options[:set_if_not_found]
+                end
+                ret = run_http(:post, "POST", key + "/incr", nil, headers)
                 ret.to_i
             end
 
-            def decrement(key, val=1)
-                ret = run_http(:post, "POST", key + "/decr", nil, {"val"=>val})
+            def decrement(key, val=1, options={})
+                headers = {"val"=>val}
+                if options[:set_if_not_found]
+                    headers["x-cc-set-if-not-found"] = options[:set_if_not_found]
+                end
+                ret = run_http(:post, "POST", key + "/decr", nil, headers)
                 ret.to_i
             end
 

data/test/cache_tests.rb

@@ -20,196 +20,222 @@ class CacheTests < Test::Unit::TestCase
         @cache = ActiveSupport::Cache::CloudCache.new(props['access_key'], props['secret_key'])
     end
 
-
     def teardown
         @cache.shutdown unless @cache.nil?
     end
 
     def test_auth
-        @cache.auth()
-    end
+           @cache.auth()
+       end
+
+       def test_bad_auth
+
+           temp = @cache.secret_key
+           @cache.secret_key = "badkey"
+
+           assert_raise Net::HTTPServerException do
+               test_basic_ops
+           end
+
+           @cache.secret_key = temp
+       end
+
+       def test_basic_ops
+           to_put = "I am a testing string. Take me apart and put me back together again."
+           @cache.put("s1", to_put)
+
+           sleep(1)
+
+           response = @cache.get("s1")
+           assert_equal(to_put, response)
 
-    def test_bad_auth
+       end
 
-        temp = @cache.secret_key
-        @cache.secret_key = "badkey"
+       def test_not_exists
+           assert_nil @cache.get("does_not_exist")
+       end
 
-        assert_raise Net::HTTPServerException do
-            test_basic_ops
-        end
+       def test_delete
+           to_put = "I am a testing string. Take me apart and put me back together again."
+           @cache.put("s1", to_put)
 
-        @cache.secret_key = temp
-    end
+           sleep(1)
 
-    def test_basic_ops
-        to_put = "I am a testing string. Take me apart and put me back together again."
-        @cache.put("s1", to_put, 0);
+           response = @cache.get("s1")
+           assert_equal(to_put, response)
 
-        sleep(1)
+           @cache.delete("s1")
 
-        response = @cache.get("s1")
-        assert_equal(to_put, response)
+           response = @cache.get("s1")
+           assert_nil(response)
+       end
 
-    end
+       def test_expiry
+           to_put = "I am a testing string. Take me apart and put me back together again."
+           @cache.put("s1", to_put, :ttl=>2);
+           sleep(4)
+           response = @cache.get("s1")
+           assert_nil(response)
 
-    def test_not_exists
-        assert_nil @cache.get("does_not_exist")
-    end
+           @cache.write("s1", to_put, :expires_in=>2);
+           sleep(4)
+           response = @cache.get("s1")
+           assert_nil(response)
+       end
 
-    def test_delete
-        to_put = "I am a testing string. Take me apart and put me back together again."
-        @cache.put("s1", to_put, 0)
+       def test_list_keys
+           @cache.put("k1", "v2", :expires_in=>15)
+           sleep 1
+           keys = @cache.list_keys
+           puts("PRINTING KEYS:")
+           for key in keys
+               puts key
+           end
+           haskey = keys.index("k1")
+           assert_not_nil(haskey)
+       end
 
-        sleep(1)
+       def test_counters
+           val = 0
+           key = "counter1" # should add a test for a key with a slash
+           @cache.put(key, val, :ttl=>50000, :raw=>true)
+           10.times do
+               val = @cache.increment(key)
+               puts 'val=' + val.to_s
+           end
+           assert_equal(10, val)
 
-        response = @cache.get("s1")
-        assert_equal(to_put, response)
+           # get as normal int now
+           get_val = @cache.get_i(key)
+           assert_equal(10, get_val)
 
-        @cache.delete("s1");
+           10.times do
+               val = @cache.decrement(key)
+           end
+           assert_equal(0, val)
 
-        response = @cache.get("s1")
-        assert_nil(response)
-    end
+           # One more to make sure it stays at 0
+           val = @cache.decrement(key)
+           assert_equal(0, val)
 
-    def test_expiry
-        to_put = "I am a testing string. Take me apart and put me back together again."
-        @cache.put("s1", to_put, 2);
+       end
 
-        sleep(4)
+       def test_flush
+           x = @cache.flush
+           assert_equal('[]', x)
+       end
 
-        response = @cache.get("s1")
-        assert_nil(response)
-    end
+       def test_stats
+           x = @cache.stats
+           puts x
+       end
 
-    def test_list_keys
-        @cache.put("k1", "v2", 1000)
-        sleep 1
-        keys = @cache.list_keys
-        puts("PRINTING KEYS:")
-        for key in keys
-            puts key
-        end
-        haskey = keys.index("k1")
-        assert_not_nil(haskey)
-    end
+       def test_get_multi_raw
+           @cache.remove("m1") rescue false
+           @cache.remove("m2") rescue false
+           @cache.remove("m3") rescue false
+           @cache.remove("m4") rescue false
 
-    def test_counters
-        val = 0
-        key = "counter1"
-        @cache.put(key, val, 50000, true)
-        10.times do
-            val = @cache.increment(key)
-        end
-        assert_equal(10, val)
+           @cache.put("m1", "v1", :ttl=>500, :raw=>true)
+           @cache.put("m2", "v2", :ttl=>500, :raw=>true)
 
-        # get as normal int now
-        get_val = @cache.get_i(key)
-        assert_equal(10, get_val)
+           kz = Array["m1", "m2", "m3"]
+           vz = @cache.get_multi(kz, :raw=>true)
 
-        10.times do
-            val = @cache.decrement(key)
-        end
-        assert_equal(0, val)
+           assert_equal("v1", vz["m1"])
+           assert_equal("v2", vz["m2"])
+           assert_nil(vz["m3"])
 
-        # One more to make sure it stays at 0
-        val = @cache.decrement(key)
-        assert_equal(0, val)
 
-    end
+       end
 
-    def test_flush
-        x = @cache.flush
-        assert_equal('[]', x)
-    end
-
-    def test_stats
-        x = @cache.stats
-        puts x
-    end
+       def test_get_multi
 
-    def test_get_multi_raw
-        @cache.remove("m1") rescue false
-        @cache.remove("m2") rescue false
-        @cache.remove("m3") rescue false
-        @cache.remove("m4") rescue false
+           kz = []
+           vz = @cache.get_multi(kz)
+           assert vz.size == 0
 
-        @cache.put("m1", "v1", 500, true)
-        @cache.put("m2", "v2", 500, true)
+           kz = ["nothere"]
+           vz = @cache.get_multi(kz)
+           assert vz.size == 0
 
-        kz = Array["m1", "m2", "m3"]
-        vz = @cache.get_multi(kz, true)
+           @cache.remove("m1") rescue false
+           @cache.remove("m2") rescue false
+           @cache.remove("m3") rescue false
+           @cache.remove("m4") rescue false
 
-        assert_equal("v1", vz["m1"]);
-        assert_equal("v2", vz["m2"]);
-        assert_nil(vz["m3"]);
+           @cache.put("m1", "v1", :ttl=>500, :raw=>false)
+           @cache.put("m2", "v2", :ttl=>500, :raw=>false)
+           @cache.put("m4", MyClass.new("Travis", 10), :ttl=>500, :raw=>false)
+
+           kz = ["m1", "m2", "m3", "m4"]
+           vz = @cache.get_multi(kz)
+
+           assert_equal("v1", vz["m1"]);
+           assert_equal("v2", vz["m2"]);
+           assert_nil(vz["m3"]);
+           assert_equal("Travis", vz["m4"].name)
+           assert_equal(10, vz["m4"].age)
 
+           @cache.put("m3", MyClass.new("Leroy", 3), :ttl=>500, :raw=>false)
+
+           kz = ["m1", "m2", "m3", "m4"]
+           vz = @cache.get_multi(kz)
 
-    end
+           assert_equal("v1", vz["m1"]);
+           assert_equal("v2", vz["m2"]);
+           assert_equal("Leroy", vz["m3"].name)
+           assert_equal(3, vz["m3"].age)
+           assert_equal("Travis", vz["m4"].name)
+           assert_equal(10, vz["m4"].age)
 
-    def test_get_multi
 
-        kz = []
-        vz = @cache.get_multi(kz)
-        assert vz.size == 0
+       end
 
-        kz = ["nothere"]
-        vz = @cache.get_multi(kz)
-        assert vz.size == 0
+       def test_big
+           s = random_string(100000)
+           @cache.put("s1", s)
 
-        @cache.remove("m1") rescue false
-        @cache.remove("m2") rescue false
-        @cache.remove("m3") rescue false
-        @cache.remove("m4") rescue false
+           s2 = @cache.get("s1")
 
-        @cache.put("m1", "v1", 500, false)
-        @cache.put("m2", "v2", 500, false)
-        @cache.put("m4", MyClass.new("Travis", 10), 500, false)
+           assert_equal(s, s2)
+       end
 
-        kz = ["m1", "m2", "m3", "m4"]
-        vz = @cache.get_multi(kz)
+       def random_string(length=10)
+           chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
+           password = ''
+           length.times { password << chars[rand(chars.size)] }
+           password
+       end
 
-        assert_equal("v1", vz["m1"]);
-        assert_equal("v2", vz["m2"]);
-        assert_nil(vz["m3"]);
-        assert_equal("Travis", vz["m4"].name)
-        assert_equal(10, vz["m4"].age)
+       def test_usage
+           usage = @cache.usage
+           assert_kind_of(Numeric, usage)
+       end
 
-        @cache.put("m3", MyClass.new("Leroy", 3), 500, false)
 
-        kz = ["m1", "m2", "m3", "m4"]
-        vz = @cache.get_multi(kz)
+    def test_set_if_not_found
+        key = "sinf"
+        @cache.delete(key)
 
-        assert_equal("v1", vz["m1"]);
-        assert_equal("v2", vz["m2"]);
-        assert_equal("Leroy", vz["m3"].name)
-        assert_equal(3, vz["m3"].age)
-        assert_equal("Travis", vz["m4"].name)
-        assert_equal(10, vz["m4"].age)
-
-
-    end
-
-    def test_big
-        s = random_string(1500)
-        @cache.put("s1", s)
-
-        s2 = @cache.get("s1")
+        assert_raise Net::HTTPServerException do
+            @cache.increment(key, 1)
+        end
 
-        assert_equal(s, s2)
-    end
+        val = 3
+        @cache.increment(key, 1, :set_if_not_found=>val)
 
-    def random_string(length=10)
-        chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
-        password = ''
-        length.times { password << chars[rand(chars.size)] }
-        password
     end
 
-    def test_usage
-        usage = @cache.usage
-        assert_kind_of(Numeric, usage)
+    def test_failing_data
+        fname = "fail_message.txt"
+        return if !File.exists?(fname)
+        file = File.new fname
+        result = file.read # JSON.parse(file.read)
+        file.close
+        puts result.inspect
+        @cache.put("bigolmsg", result)
     end
 
 
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: quetzall-cloud_cache
 version: !ruby/object:Gem::Version 
-  version: 1.1.6
+  version: 1.2.0
 platform: ruby
 authors: 
 - Travis Reeder
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-13 00:00:00 -07:00
+date: 2009-09-09 00:00:00 -07:00
 default_executable: 
 dependencies: []