jruby-ehcache-rails3 1.2.0 → 1.3.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.DS_Store
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Gemfile for the ehcache gem
+gemspec :name => "jruby-ehcache"

data/Gemfile.lock

@@ -0,0 +1,15 @@
+PATH
+  remote: .
+  specs:
+    jruby-ehcache (1.3.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  jruby-ehcache!

data/History.txt

@@ -0,0 +1,15 @@
+== 0.0.3 2008-08-20
+* 1 bug fix
+  * removed un-needed marshalling
+* 1 major enhancement
+  * added support for configurable bootstrap cache loader and event listener
+
+== 0.0.2 2008-06-08
+
+* 1 bug fix
+  * add mutex, and marshalling for serialization to cache
+
+== 0.0.1 2008-06-05
+
+* 1 major enhancement:
+  * Initial release

data/License.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2008 - 2010 Dylan Stamat <dstamat@elctech.com> and
+                          Jason Voegele <jason@jvoegele.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 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 furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,37 @@
+History.txt
+License.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+bin/ehcache
+config/ehcache.yml
+config/hoe.rb
+config/requirements.rb
+ext/ehcache-1.4.1/ehcache-1.4.1-remote-debugger.jar
+ext/ehcache-1.4.1/ehcache-1.4.1.jar
+ext/ehcache-1.4.1/lib/backport-util-concurrent-3.0.jar
+ext/ehcache-1.4.1/lib/commons-logging-1.0.4.jar
+ext/ehcache-1.4.1/lib/jsr107cache-1.0.jar
+ext/rails/ehcache_store.rb
+lib/ehcache.rb
+lib/ehcache/cache.rb
+lib/ehcache/cache_manager.rb
+lib/ehcache/config.rb
+lib/ehcache/element.rb
+lib/ehcache/extensions.rb
+lib/ehcache/java.rb
+lib/ehcache/status.rb
+lib/ehcache/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/spec_helper.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+test/test_ehcache.rb
+test/test_ehcachejr.rb
+test/test_helper.rb

data/PostInstall.txt

@@ -0,0 +1,2 @@
+For more information on this gem, and Ehcache proper, see:
+http://github.com/dylanz/ehcache/tree/master/README.txt

data/README.txt

@@ -51,6 +51,15 @@ OR
 $ jruby -S gem install jruby-ehcache-rails3
 
 
+== GEMFILE:
+
+Add the gem as you normally would in your Gemfile, making sure to require
+'ehcache' explicitly.  Here is an example of adding the rails3 gem to a Gemfile.
+
+gem 'jruby-ehcache-rails3', :require => 'ehcache'
+
+
+
 == REQUIREMENTS:
 
 Tested with JRuby 1.5.3.

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_helper"
+Bundler::GemHelper.install_tasks :name => "jruby-ehcache"
+
+task :default => [ :test ]
+
+require 'rdoc/task'
+require 'rake/testtask'
+desc "Executes the test suite"
+Rake::TestTask.new do |t|
+  t.name = :test
+  t.libs << 'lib' << 'ext' << 'test'
+  t.pattern = "test/test_*.rb"
+end

data/VERSION

@@ -0,0 +1 @@
+1.3.0

data/config/ehcache.yml

@@ -0,0 +1,22 @@
+disk_store:
+  path: java.io.tmpdir
+
+peer_providers:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory
+  properties: peerDiscovery=automatic,multicastGroupAddress=230.0.0.1,multicastGroupPort=4446,timeToLive=1
+  property_separator: "\,"
+
+peer_listeners:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory
+
+default_cache:
+  name: cache
+  max_elements_in_memory:  10000
+  time_to_live_seconds:  0
+  time_to_idle_seconds:  0
+  overflow_to_disk: true
+  eternal: false
+  disk_spool_buffer_size_mb: 30
+  disk_persistent: false
+  disk_expiry_thread_interval_seconds: 120
+  memory_store_eviction_policy: LRU

data/config/ehcache_manual_rmi.yml

@@ -0,0 +1,27 @@
+disk_store:
+  path: java.io.tmpdir
+
+peer_providers:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory
+  properties: peerDiscovery=manual,rmiUrls=//that_hostname:40001/cache
+  property_separator: "\,"
+
+peer_listeners:
+- class: net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory
+  properties: hostName=this_hostname,port=40000
+
+default_cache:
+  name: cache
+  max_elements_in_memory:  10000
+  time_to_live_seconds:  0
+  time_to_idle_seconds:  0
+  overflow_to_disk: true
+  eternal: false
+  disk_spool_buffer_size_mb: 30
+  disk_persistent: false
+  disk_expiry_thread_interval_seconds: 120
+  memory_store_eviction_policy: LRU
+  event_listener: { class: net.sf.ehcache.distribution.RMICacheReplicatorFactory }
+  bootstrap_loader: { class: net.sf.ehcache.distribution.RMIBootstrapCacheLoaderFactory,
+                      properties: 'bootstrapAsynchronously=true,maximumChunkSizeBytes=5000000',
+                      property_separator: "\," }

data/examples/ehcache.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="../../main/config/ehcache.xsd">
+
+    <!-- Disable for test ehcache.xml. Should go to the same place. -->
+    <diskStore path="java.io.tmpdir"/>
+
+    <cacheManagerPeerProviderFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerProviderFactory"
+                                     properties="peerDiscovery=automatic, multicastGroupAddress=230.0.0.1, multicastGroupPort=4446, timeToLive=0"/>
+
+
+    <cacheManagerPeerListenerFactory class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"
+                                     properties="hostName=, port=, socketTimeoutMillis="/>
+
+
+    <defaultCache
+            name="default"
+            maxElementsInMemory="10"
+            eternal="false"
+            timeToIdleSeconds="5"
+            timeToLiveSeconds="10"
+            overflowToDisk="true"
+            />
+
+
+    <!-- Sample cache named sampleCache1 -->
+    <cache name="sampleCache1"
+           maxElementsInMemory="10000"
+           maxElementsOnDisk="1000"
+           eternal="false"
+           timeToIdleSeconds="360"
+           timeToLiveSeconds="1000"
+           overflowToDisk="true">
+    </cache>
+
+    <!-- Sample cache named sampleCache2. Is eternal. Is diskPersistent but does not overflow to disk -->
+    <cache name="sampleCache2"
+           maxElementsInMemory="1000"
+           eternal="true"
+           overflowToDisk="false"
+           diskPersistent="true"
+            />
+</ehcache>

data/examples/jruby-ehcache.rb

@@ -0,0 +1,13 @@
+require 'ehcache'
+
+manager = Ehcache::CacheManager.new
+cache = manager.cache
+
+cache.put("answer", "42", {:ttl => 120})
+answer = cache.get("answer")
+puts "Answer: #{answer}"
+
+question = cache.get("question") || 'unknown'
+puts "Question: #{question}"
+
+manager.shutdown

data/jruby-ehcache-rails2.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ehcache/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{jruby-ehcache-rails2}
+  s.version = Ehcache::VERSION
+  s.authors = [%q{Dylan Stamat}, %q{Jason Voegele}]
+  s.date = %q{2012-03-14}
+  s.description = %q{The Ehcache cache store provider for Rails 2}
+  s.email = [%q{dstamat@elctech.com}, %q{jvoegele@terracotta.org}]
+  s.extra_rdoc_files = [ "README.txt" ]
+  s.homepage = %q{http://ehcache.rubyforge.org}
+  s.rubyforge_project = %q{ehcache}
+  s.rubygems_version = %q{1.8.9}
+  s.summary = %q{Rails 2 cache store provider using Ehcache}
+
+  s.files = `git ls-files`.split("\n").concat(
+      ["lib/active_support/ehcache_store.rb",
+       "lib/ehcache/active_support_store.rb"])
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "jruby-ehcache"
+end

data/jruby-ehcache-rails3.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ehcache/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{jruby-ehcache-rails3}
+  s.version = Ehcache::VERSION
+  s.authors = [%q{Dylan Stamat}, %q{Jason Voegele}]
+  s.date = %q{2012-03-14}
+  s.description = %q{The Ehcache cache store provider for Rails 3}
+  s.email = [%q{dstamat@elctech.com}, %q{jvoegele@terracotta.org}]
+  s.extra_rdoc_files = [ "README.txt" ]
+  s.homepage = %q{http://ehcache.rubyforge.org}
+  s.rubyforge_project = %q{ehcache}
+  s.rubygems_version = %q{1.8.9}
+  s.summary = %q{Rails 3 cache store provider using Ehcache}
+
+  s.files = `git ls-files`.split("\n").concat(
+      ["lib/active_support/cache/ehcache_store.rb",
+       "lib/ehcache/active_support_store.rb"])
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "jruby-ehcache"
+end

data/jruby-ehcache.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ehcache/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{jruby-ehcache}
+  s.version = Ehcache::VERSION
+  s.authors = [%q{Dylan Stamat}, %q{Jason Voegele}]
+  s.date = %q{2012-03-14}
+  s.description = %q{JRuby interface to the popular Java caching library Ehcache}
+  s.email = [%q{dstamat@elctech.com}, %q{jvoegele@terracotta.org}]
+  s.extra_rdoc_files = [ "README.txt" ]
+  s.homepage = %q{http://ehcache.rubyforge.org}
+  s.rubyforge_project = %q{ehcache}
+  s.rubygems_version = %q{1.8.9}
+  s.summary = %q{JRuby interface to Ehcache}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

data/lib/ehcache/active_support_store.rb

@@ -44,4 +44,15 @@ module Ehcache
     end
 
   end
-end
+end
+
+if defined?(Rails)
+  Ehcache::ActiveSupportStore.default_cache_name = 'rails_cache'
+
+  case Rails::VERSION::MAJOR
+  when 2
+    Ehcache::ActiveSupportStore.config_directory = File.expand_path(File.join(RAILS_ROOT, 'config'))
+  when 3
+    Ehcache::ActiveSupportStore.config_directory = File.expand_path(File.join(::Rails.root, 'config'))
+  end
+end

data/lib/ehcache/cache.rb

@@ -0,0 +1,74 @@
+# Enhance net.sf.ehcache.Cache with a more Rubyesque API.
+class Java::NetSfEhcache::Cache
+  include Enumerable
+
+  # Yield each Element stored in this cache to the given block.  This method
+  # uses Cache#getKeys as its basis, and therefore it is possible that some
+  # of the yielded elements have expired.
+  def each
+    for key in self.getKeys
+      yield self.get(key)
+    end
+  end
+
+  # Does this cache require marshalling of Ruby objects?
+  def marshal?
+    config = self.cache_configuration
+    config.overflow_to_disk? || config.overflow_to_off_heap? || config.terracotta_clustered?
+  end
+
+  # Gets an element value from the cache.  Unlike the #get method, this method
+  # returns the element value, not the Element object.
+  def [](key)
+    element = self.get(key)
+    element ? element.value : nil
+  end
+
+  alias ehcache_put put
+
+  # Wrap the Cache#put method to allow for extra options to be passed to the
+  # created Element.
+  def put(*args)
+    options = args.extract_options!
+    if args.size == 1 && args.first.kind_of?(Ehcache::Element)
+      element = args.first
+    elsif args.size == 2
+      if marshal?
+        value = Java::NetSfEhcache::MarshaledRubyObject.new(Marshal.dump(args[1]).to_java_bytes)
+      end
+      element = Ehcache::Element.create(args[0], value, options)
+    else
+      raise ArgumentError, "Must be Element object or key and value arguments"
+    end
+
+    if options[:unless_exist] || options[:unlessExist] ||
+       options[:if_absent]    ||options[:ifAbsent]
+      put_if_absent(element)
+    else
+      ehcache_put(element)
+    end
+  end
+
+  alias []= put
+
+  alias include? isKeyInCache
+  alias member? isKeyInCache
+
+  # Atomic compare and swap for cache elements.  Invokes the given block with
+  # the current value of the element and attempts to replace it with the
+  # value returned from the block, repeating until replace returns true.
+  # Note that the provided block works only with element values, not Element
+  # objects: the result of element.getValue is passed to the block parameter,
+  # and the block is expected to return a value based on it.
+  # If there is no element with the given key, returns immediately without
+  # retrying.
+  def compare_and_swap(key, &block)
+    begin
+      old_element = self.get(key)
+      return nil unless old_element
+      new_element = Ehcache::Element.new(key, yield(old_element.value))
+    end until replace(old_element, new_element)
+  end
+
+  alias update compare_and_swap
+end

data/lib/ehcache/cache_manager.rb

@@ -0,0 +1,69 @@
+# Enhance net.sf.ehcache.CacheManager with a more Rubyesque API.
+class Java::NetSfEhcache::CacheManager
+  include Enumerable
+
+  class << self
+    alias_method :ehcache_create, :create
+
+    # Enhanced create that provides for some extra configuration options.
+    # Specifically, String arguments may be used where native Ehcache expects
+    # java.io.File objects, and if the String refers to a YAML file it will be
+    # used as the Configuration source.
+    def create(*args)
+      process_init_args(*args) do |*args|
+        ehcache_create(*args)
+      end
+    end
+  end
+
+  # Enhanced constructor that provides for some extra configuration options.
+  # Specifically, String arguments may be used where native Ehcache expects
+  # java.io.File objects, and if the String refers to a YAML file it will be
+  # used as the Configuration source.
+  def initialize(*args)
+    process_init_args(*args) do |*args|
+      super(*args)
+    end
+  end
+
+  # Iterate through each cache managed by this CacheManager.
+  def each
+    for name in self.cache_names
+      yield self.get_ehcache(name)
+    end
+  end
+
+  alias [] get_ehcache
+
+  def cache(cache_name = '__default_jruby_cache')
+    self.add_cache_if_absent(cache_name)
+    self.get_ehcache(cache_name)
+  end
+
+  # true if cache by given name is being managed, false otherwise
+  def include?(cache_name)
+    self.cache_exists(cache_name)
+  end
+  alias_method :exists?, :include?
+end
+
+# Helper method for processing initialization arguments passed to
+# CacheManager.create and CacheManager#initialize.
+def process_init_args(*args)
+  args.compact!
+  if args.empty?
+    # First, look relative to the file that is creating the CacheManager.
+    # The expression caller[2] finds the entry in the call stack where
+    # CacheManager.new or CacheManager.create was called.
+    creator = /^(.+?):\d/.match(caller[2])[1]
+    if ehcache_config = Java::NetSfEhcacheConfig::Configuration.find(File.dirname(creator))
+      yield(ehcache_config)
+    else
+      yield
+    end
+  elsif args.size == 1 && args.first.is_a?(String)
+    yield(Ehcache::Config::Configuration.create(args.first))
+  else
+    yield(*args)
+  end
+end

data/lib/ehcache/config.rb

@@ -0,0 +1,51 @@
+require 'ehcache/yaml_config'
+
+# Enhance net.sf.ehcache.config.Configuration with a more Rubyesque API, and
+# add support for using YAML for configuration.
+class Java::NetSfEhcacheConfig::Configuration
+  Factory = Java::NetSfEhcacheConfig::ConfigurationFactory
+
+  # Searches for an Ehcache configuration file and, if found, returns a
+  # Configuration object created from it.  The search algorithm looks for
+  # files named "ehcache.yml" or "ehcache.xml", first looking in the provided
+  # directories in order, and if not found there then looking in the Ruby
+  # $LOAD_PATH.
+  # Returns nil if no configuration file is found.
+  def self.find(*dirs)
+    file_names = %w[ehcache.yml ehcache.xml]
+    dirs += $LOAD_PATH
+    dirs.each do |dir|
+      file_names.each do |name|
+        candidate = File.join(dir, name)
+        return create(candidate) if File.exist?(candidate)
+      end
+    end
+    nil
+  end
+
+  def self.create(*args)
+    result = nil
+    case args.size
+    when 0
+      result = Factory.parseConfiguration()
+    when 1
+      arg = args.first
+
+      if arg.is_a?(String)
+        raise ArgumentError, "Cannot read config file '#{arg}'" unless File.readable?(arg)
+        if arg =~ /\.yml$/
+          result = Ehcache::Config::YamlConfig.parse_yaml_config(arg)
+        else
+          result = Factory.parseConfiguration(java.io.File.new(arg))
+        end
+      else
+        result = Factory.parseConfiguration(arg)
+      end
+    end
+
+    unless result.is_a?(self)
+      raise ArgumentError, "Could not create Configuration from: #{args.inspect}"
+    end
+    result
+  end
+end

data/lib/ehcache/element.rb

@@ -0,0 +1,36 @@
+# Enhance net.sf.ehcache.Element with a more Rubyesque API.
+class Java::NetSfEhcache::Element
+  def self.create(key, value, options = {})
+    result = self.new(key, value)
+    options.each do |key, value|
+      setter = "#{key}=".to_sym
+      result.send(setter, value) if result.respond_to?(setter)
+    end
+    result
+  end
+
+  alias element_value value
+
+  # Wrap the Element#value method to unmarshal Ruby objects if necessary.
+  def value
+    val = element_value
+    if val.kind_of?(Java::NetSfEhcache::MarshaledRubyObject)
+      Marshal.load(String.from_java_bytes(val.bytes))
+    else
+      val
+    end
+  end
+
+  alias tti getTimeToIdle
+  alias ttl getTimeToLive
+
+  alias tti= setTimeToIdle
+  alias ttl= setTimeToLive
+  
+  alias expires_in getTimeToLive
+  def expires_in=(seconds)
+    setTimeToLive(seconds.to_i)
+  end
+  alias expiresIn expires_in
+  alias expiresIn= expires_in=
+end

data/lib/ehcache/java.rb

@@ -0,0 +1,57 @@
+require 'java'
+
+EHCACHE_LIBS_DIR = "#{Ehcache::EHCACHE_HOME}/ext"
+
+module Ehcache
+  module Rails
+    RAILS_ROOT_DIR = if defined?(::Rails)
+          ::Rails.root.to_s
+        elsif defined?(RAILS_ROOT)
+          RAILS_ROOT
+        end
+    if RAILS_ROOT_DIR
+      RAILS_LIB_DIR = File.join(RAILS_ROOT_DIR, 'lib')
+      Dir["#{RAILS_LIB_DIR}/**/*.jar"].each do |jar|
+        $CLASSPATH << File.expand_path(jar)
+      end
+    end
+  end
+  Dir["#{EHCACHE_LIBS_DIR}/**/*.jar"].each do |jar|
+    $CLASSPATH << File.expand_path(jar)
+  end
+  LOG = Java::OrgSlf4j::LoggerFactory.getLogger("JRubyEhcache")
+  LOG.info("Using Ehcache version #{Java::NetSfEhcacheUtil::ProductInfo.new.getVersion()}")
+=begin
+  slf4j_loader = lambda { Java::OrgSlf4j::LoggerFactory.getLogger("JRubyEhcache") }
+  begin
+    LOG = slf4j_loader.call
+    LOG.info("Using SLF4J Logger from CLASSPATH")
+  rescue NameError
+    Dir["#{EHCACHE_LIBS_DIR}/**/*slf4j*.jar"].each do |l| require l end
+    LOG = slf4j_loader.call
+    LOG.info("Using bundled SLF4J Logger")
+  end
+
+  ehcache_version_loader = lambda {
+    Java::NetSfEhcacheUtil::ProductInfo.new.getVersion()
+  }
+  begin
+    # If Ehcache is already on the classpath, use it.
+    VERSION = ehcache_version_loader.call
+    LOG.info("Using Ehcache #{VERSION} from CLASSPATH")
+  rescue NameError
+    # If not, use the Ehcache bundled with the jruby-ehcache gem.
+    Dir["#{EHCACHE_LIBS_DIR}/**/*.jar"].each do |l|
+      require l unless l =~ /slf4j/
+    end
+    VERSION = ehcache_version_loader.call
+    LOG.info("Using bundled Ehcache #{VERSION}")
+  end
+=end
+  include_package 'net.sf.ehcache'
+
+  module Config
+    include_package 'net.sf.ehcache.config'
+  end
+
+end

data/lib/ehcache/version.rb

@@ -0,0 +1,3 @@
+module Ehcache
+  VERSION = "1.3.0"
+end