gemfire-jruby 0.0.7 → 0.0.8

data/README

@@ -27,3 +27,4 @@ require 'rubygems'
 require 'lib/gemfire-jruby'
 client = ActiveSupport::Cache::GemFire.getInstance('client', {'locators'=>'localhost:10355', 'region-name'=>'data'})
 
+

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/gemfire-jruby.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gemfire-jruby}
-  s.version = "0.0.7"
+  s.version = "0.0.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan McKean"]
-  s.date = %q{2010-01-29}
+  s.date = %q{2010-02-05}
   s.description = %q{"Uses Memcached API"}
   s.email = %q{alan.mckean@gemstone.com}
   s.extra_rdoc_files = [
@@ -49,7 +49,9 @@ Gem::Specification.new do |s|
      "doc/index.html",
      "doc/rdoc-style.css",
      "gemfire-jruby.gemspec",
+     "lib/examples.rb",
      "lib/gemfire-jruby.rb",
+     "server.rb",
      "test/helper.rb",
      "test/test_gemfire-jruby.rb"
   ]

data/lib/examples.rb

@@ -0,0 +1,100 @@
+# run this in jirb
+require 'rubygems'
+require 'gemfire-jruby'
+
+## create the server
+server = GemFireServer.new('localhost:10355')
+# copy and paste the ExampleCacheListener class (below) into the server shell
+server.addListener(ExampleCacheListener.new)
+
+# Now, in another jirb shell
+require 'rubygems'
+require 'gemfire-jruby'
+
+## create the client
+client = GemFireClient.new('localhost:10355')
+# copy and paste the ExampleCacheListener class (below) into the server shell
+client.addListener(ExampleCacheListener.new)
+
+# Put some data into the client shell ... the listeners should fire in both shells
+(1..12).each do |key| client.write(key, Date.new(key,key,key)) end
+
+# Explore the client api in the client shell
+client.read(1)
+client.keys
+client.exist?(1)
+
+# Try the server api in the server shell
+server.read(1)
+server.keys
+server.exist?(1)
+
+# Back in the client shell
+client.delete(1)
+client.exist?(1)
+
+# Check in the server shell
+server.exist?(1)
+
+class ExampleCacheListener
+  def afterCreate(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + ' was created with ' + YAML::load(entryEvent.getNewValue).to_s
+  end
+  def afterUpdate(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + ' was updated to ' + YAML::load(entryEvent.getNewValue).to_s
+  end
+  def afterDestroy(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + 'was destroyed'
+  end
+  def afterInvalidate(entryEvent)
+  end
+  def afterRegionCreate(regionEvent)
+    puts 'Region ' + regionEvent.getRegion.getName + 'was created'
+  end
+  def afterRegionDestroy(regionEvent)
+    puts 'Region ' + regionEvent.getRegion.getName + 'was destroyed'
+  end
+  def afterRegionClear(regionEvent)
+    puts 'Region ' + regionEvent.getRegion.getName + 'was cleared'
+  end
+  def afterRegionInvalidate(regionEvent)
+  end
+  def afterRegionLive(regionEvent)
+  end
+  def close
+    puts 'CacheListener is closing'
+  end
+end
+
+class ExampleCacheWriter
+  def beforeCreate(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + ' is about to be created with ' + YAML::load(entryEvent.getNewValue).to_s
+  end
+  def beforeUpdate(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + ' is about to be updated to ' + YAML::load(entryEvent.getNewValue).to_s
+  end
+  def beforeDestroy(entryEvent)
+    puts YAML::load(entryEvent.getKey).to_s + ' is about to be destroyed'
+  end
+  def beforeRegionDestroy(regionEvent)
+    puts 'Region ' + regionEvent.getRegion.getName + ' is about to be destroyed'
+  end
+  def beforeRegionClear(regionEvent)
+    puts 'Region ' + regionEvent.getRegion.getName + ' is about to be cleared'
+  end
+  def close
+    puts 'CacheWriter is closing'
+  end
+end
+
+class ExampleCacheLoader
+  def load(helper)
+    puts 'Loading ' + YAML::load(helper.getKey).to_s 
+    'V' + YAML::load(helper.getKey).to_s
+  end
+  def close
+    puts 'CacheLoader is closing'
+  end
+end
+
+

data/lib/gemfire-jruby.rb

@@ -56,26 +56,52 @@ module ActiveSupport
           logger.error("GemfireCache Creation Error (#{e}): #{e.message}")
     	end
 
+      # GemFire api
+      def create(key, value)
+        @region.create(key.to_yaml, value.to_yaml)
+      rescue CacheException => e
+        logger.error("GemfireCache Error (#{e}): #{e.message}")
+      end
+
+      def put(key, value)
+        @region.put(key.to_yaml, value.to_yaml)
+      rescue CacheException => e
+        logger.error("GemfireCache Error (#{e}): #{e.message}")
+      end
+
+      def invalidate(key)
+        @region.invalidate(key.to_yaml)
+      rescue CacheException => e
+        logger.error("GemfireCache Error (#{e}): #{e.message}")
+      end
+
+      #  Destroy the entry stored in the GemFire cache at _key_. _key_ can be any JRuby object. Returns the value that was deleted.
+      def destroy(key)
+        @region.destroy(key.to_yaml)
+      rescue CacheException => e
+        logger.error("GemfireCache Error (#{e}): #{e.message}")
+      end
+
       # Read a value from the GemFire cache. _key_ can be any JRuby object. Returns the value stored at _key_.
       def read(key)
         super
-        Marshal.load(@region.get(Marshal.dump(key)))
+        YAML::load(@region.get(key.to_yaml))
       rescue CacheException => e
           logger.error("GemfireCache Error (#{e}): #{e.message}")
       end
 
-      # Write a value to the GemFire cache. _key_ is used to read the value from the cache and can be any JRuby object. Returns the value that was stored at _key_.
+      # Alias for put(key, value) ... for compatibility with memcached
       def write(key, value)
         super
-        @region.put(Marshal.dump(key), Marshal.dump(value))
+        @region.put(key.to_yaml, value.to_yaml)
       rescue CacheException => e
         logger.error("GemfireCache Error (#{e}): #{e.message}")
       end
 
-      # Delete the entry stored in the GemFire cache at _key_. _key_ can be any JRuby object. Returns the value that was deleted.
+      # Alias for destroy(key) ... for compatibility with memcached
       def delete(key)
         super
-        @region.destroy(Marshal.dump(key))
+        @region.destroy(key.to_yaml)
       rescue CacheException => e
         logger.error("GemfireCache Error (#{e}): #{e.message}")
       end
@@ -84,21 +110,21 @@ module ActiveSupport
       def keys(onServer=true)
         keySet = nil
         result = []
-        if (onServer && @role == 'client') then
+        if (onServer && (@role == 'client')) then
           keySet = @region.keySetOnServer
         else
-          keySet = @region.keys
+          keySet = @region.keySet
         end
-        keySet.each do |k| result << Marshal.load(k) end
+        keySet.each do |k| result << YAML::load(k) end
         result
       end
 
       # Check if there is an entry accessible by _key_ in the GemFire cache. Returns a boolean.
       def exist?(key)
         if @region.getAttributes.getPoolName then
-          @region.containsKey(Marshal.dump(key))
+          @region.containsKeyOnServer(key.to_yaml)
         else
-          @region.containsKeyOnServer(Marshal.dump(key))
+          @region.containsKey(key.to_yaml)
         end
       end
 
@@ -108,6 +134,29 @@ module ActiveSupport
       rescue CacheException => e
         logger.error("GemfireCache Error (#{e}): #{e.message}")
       end
+      
+      # Add a CacheListener to the cache region
+      def addListener(cacheListener)
+        @region.getAttributesMutator.addCacheListener(cacheListener)
+      end
+
+      # Install a CacheWriter into the client's cache region
+      def setWriter(cacheWriter)
+        if @role == 'server' then
+          @region.getAttributesMutator.setCacheWriter(cacheWriter)
+        else
+          raise 'Only servers can have CacheWriters'
+        end
+      end
+
+      # Install a CacheLoader into the cache region
+      def setLoader(cacheLoader)
+        if @role == 'server' then
+          @region.getAttributesMutator.setCacheLoader(cacheLoader)
+        else
+          raise 'Only servers can have CacheLoaders'
+        end
+      end
 
       # Not implemented by GemFire. Raises an exception when called.
       def increment(key)
@@ -146,7 +195,8 @@ module ActiveSupport
         properties = Properties.new
         properties.setProperty('mcast-port', '0')
         options.each do |key, value|
-          properties.setProperty(key, value) unless ((key == 'cacheserver-port') || (key == 'region-name') || (key == 'locators' && role == 'client'))
+          puts key
+          properties.setProperty(key, value) unless ((key == 'cacheserver-port') || (key == 'region-name') || (key == 'caching-enabled') || (key == 'locators' && role == 'client'))
         end
         properties
       end
@@ -214,3 +264,77 @@ module ActiveSupport
     end
   end
 end
+
+class GemFireCacher
+  def initialize(locator, regionName="data", cachingOn=false)
+    raise "GemFireCacher is an abstract class. Instantiate either a GemFireClient or a GemFireServer"
+  end
+  
+  # GemFire api
+  def create(key, value)
+    @gemfire.create(key, value)
+  end
+  def put(key, value)
+    @gemfire.put(key, value)
+  end
+  def invalidate(key)
+    @gemfire.invalidate(key)
+  end
+  def destroy(key)
+    @gemfire.destroy(key)
+  end
+
+  # Both servers and clients can have CacheListeners
+  def addListener(cacheListener)
+    @gemfire.addListener(cacheListener)
+  end
+
+  # Memcached api
+  def read(key)
+    @gemfire.read(key)
+  end
+  def write(key, value)
+    @gemfire.write(key, value)
+  end
+  def delete(key)
+    @gemfire.delete(key)
+  end
+  def exist?(key)
+    @gemfire.exist?(key)
+  end
+  def keys(onServer=true)
+    @gemfire.keys(onServer)
+  end
+  def clear
+    @gemfire.clear
+  end
+  def increment(key)
+    @gemfire.increment(key)
+  end
+  def decrement(key)
+    @gemfire.decrement(key)
+  end
+  def delete_matched(matcher)
+    @gemfire.delete_matched(matcher)
+  end
+end
+
+class GemFireServer < GemFireCacher
+  def initialize(locator, regionName="data", cacheServerPort=40404)
+    @gemfire = ActiveSupport::Cache::GemFire.getInstance('server', {'locators'=>locator, 'region-name'=>regionName, 'cacheserver-port'=>cacheServerPort})
+  end  
+  # Only servers can have CacheLoaders and CacheWriters
+  def setWriter(cacheWriter)
+    @gemfire.setWriter(cacheWriter)
+  end
+  def setLoader(cacheLoader)
+    @gemfire.setLoader(cacheLoader)
+  end
+end
+
+class GemFireClient < GemFireCacher
+  def initialize(locator, regionName="data", cachingOn=false)
+    @gemfire = ActiveSupport::Cache::GemFire.getInstance('client', {'locators'=>locator, 'region-name'=>regionName, 'caching-enabled'=>cachingOn.to_s})
+  end  
+end
+

data/server.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'lib/gemfire-jruby'
+require 'lib/example_cache_listener'
+require 'date'
+
+server = GemFireServer.new('localhost:10355')
+server.addListener(ExampleCacheListener.new)
+server.write(100, {'hello' => 'world', 'goodbye' => 'life'})
+
+#client = GemFireClient.new('localhost:10355')
+#client.addListener(MyListener.new)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gemfire-jruby
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Alan McKean
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-29 00:00:00 -08:00
+date: 2010-02-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -64,7 +64,9 @@ files:
 - doc/index.html
 - doc/rdoc-style.css
 - gemfire-jruby.gemspec
+- lib/examples.rb
 - lib/gemfire-jruby.rb
+- server.rb
 - test/helper.rb
 - test/test_gemfire-jruby.rb
 has_rdoc: true