jruby-ehcache 0.5.0 → 1.0.0

data/lib/ehcache/config.rb

@@ -1,128 +1,51 @@
-require 'erb'
-require 'yaml'
-
-module Ehcache
-
-  class MissingConfigurationException < StandardError
-    def initialize(search_dirs)
-      super("Could not find Ehcache configuration file in any of: #{search_dirs.inspect}")
+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
 
-  # default configuration and a cache named "cache"
-  # manager = Ehcache::CacheManager.new
-  # cache   = manager.cache
-  #
-  # default configuration and a cache named "steve"
-  # manager = Ehcache::CacheManager.new({"cache" => {"name" => "steve"}})
-  # cache   = manager.cache("steve")
-  class Config
-    CONFIG_FILE_NAME = 'ehcache.yml'
-
-    RAILS_CONFIG_DIR =
-        if defined?(::Rails)
-          File.join(::Rails.root.to_s, 'config')
-        elsif defined?(RAILS_ROOT)
-          File.join(RAILS_ROOT, 'config')
-        end
-
-    SEARCH_DIRS = [RAILS_CONFIG_DIR,
-                   File.join(ENV['HOME'], 'lib', 'config'),
-                   File.join(EHCACHE_HOME, 'config')].compact
-
-    class << self
-      def generate(options={})
-        unless config_file = find_config_file
-          raise MissingConfigurationException.new(SEARCH_DIRS)
+  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
-        config = ERB.new(File.open(config_file) {|f| f.read})
-        config = YAML.load(config.result(binding))
-        initialize_factory_proxies
-        process(config, options)
-      end
-
-      private
-
-      def find_config_file
-        SEARCH_DIRS.map {|dir| File.join(dir, CONFIG_FILE_NAME)}.find { |f|
-          File.readable?(f)
-        }
-      end
-
-      def process(config, options)
-        # merge in new defaults if any
-        config["default"].deep_merge!(options["default"]) if options["default"]
-        
-        # primary cache should be based off of default cache
-        config["cache"] = config["default"].merge({"name" => Ehcache::Cache::PRIMARY})
-
-        # update the rest of the configuration
-        config.deep_merge!(options) if options
-        config.each { |key, value| setter(key, value) }
-
-        # add default cache and primary cache if present
-        create_default_cache(config["default"])
-        create_primary_cache(config["cache"]) if config["cache"]
-
-        # populate the configuration
-        @configuration.add_disk_store(@disk)
-        @configuration.add_cache_manager_peer_provider_factory(@peer_provider)
-        @configuration.add_cache_manager_peer_listener_factory(@peer_listener)
-        @configuration
-      end
-
-      # creates and installs default cache
-      def create_default_cache(default)
-        default_cache_config = create_cache_configuration("default", default)
-        @configuration.add_default_cache(default_cache_config)
-      end
-
-      # creates and installs primary cache
-      def create_primary_cache(primary)
-        primary_cache_config = create_cache_configuration("cache", primary)
-        @configuration.add_cache(primary_cache_config)
-      end
-
-      # creates and sets up cache configurations
-      def create_cache_configuration(cache_name, data)
-        config = instance_variable_get("@#{cache_name}".intern)
-        data.each { |k,v|
-          # included hashes will be event listener factories, exception handler
-          # factories, loader factories, etc.  TODO:  clean this up, and add
-          # support for adding other factories in a cleaner fashion.
-          if v.is_a?(Hash)
-            case k
-              when "event_listener":
-                event_factory = Ehcache::Java::CacheConfiguration::CacheEventListenerFactoryConfiguration.new(config)
-                v.each { |k,v| event_factory.send("set_#{k.to_s}",v) }
-                config.add_cache_event_listener_factory(event_factory)
-              when "bootstrap_loader":
-                bootstrap_loader = Ehcache::Java::CacheConfiguration::BootstrapCacheLoaderFactoryConfiguration.new(config)
-                v.each { |k,v| bootstrap_loader.send("set_#{k.to_s}",v) }
-                config.add_bootstrap_cache_loader_factory(bootstrap_loader)
-            end
-          else
-            config.send("set_#{k.to_s}",v)
-          end
-        }
-        config
-      end
-
-      # initialize all the java factory proxies for configuration
-      def initialize_factory_proxies
-        @configuration  = Ehcache::Java::Configuration.new
-        @disk           = Ehcache::Java::DiskStoreConfiguration.new
-        @cache          = Ehcache::Java::CacheConfiguration.new
-        @default        = Ehcache::Java::CacheConfiguration.new
-        @peer_provider  = Ehcache::Java::FactoryConfiguration.new
-        @peer_listener  = Ehcache::Java::FactoryConfiguration.new
+      else
+        result = Factory.parseConfiguration(arg)
       end
+    end
 
-      # helper for setters
-      def setter(factory, config)
-        factory = instance_variable_get("@#{factory}".intern)
-        config.each { |k,v| factory.send("set_#{k.to_s}",v) unless v.is_a?(Hash) }
-      end
+    unless result.is_a?(self)
+      raise ArgumentError, "Could not create Configuration from: #{args.inspect}"
     end
+    result
   end
 end

data/lib/ehcache/element.rb

@@ -1,27 +1,17 @@
-module Ehcache
-  class Element
-    attr_accessor :key, :value
-
-    def initialize(key, value, options = {})
-      @key     = key
-      @value   = value
-      @ttl     = options[:ttl] || nil
-
-      element = Ehcache::Java::Element.new(key, value)
-      element.set_time_to_live(@ttl) if @ttl
-      @proxy = element
-    end
-
-    def ttl
-      @ttl = @proxy.get_time_to_live
+# 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
 
-    def tti
-      @tti = @proxy.get_time_to_idle
-    end
+  alias tti getTimeToIdle
+  alias ttl getTimeToLive
 
-    def proxy
-      @proxy
-    end
-  end
+  alias tti= setTimeToIdle
+  alias ttl= setTimeToLive
 end

data/lib/ehcache/extensions.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/array/extract_options'
+
 class Hash
   # Merges self with another hash, recursively.
   # This code was lovingly stolen from some random gem:

data/lib/ehcache/java.rb

@@ -1,8 +1,38 @@
+require 'java'
+
+EHCACHE_LIBS_DIR = "#{Ehcache::EHCACHE_HOME}/ext"
+
 module Ehcache
-  module Java
-    include ::Java
-    Dir["#{Ehcache::EHCACHE_HOME}/ext/**/*.jar"].sort.each {|l| require l}
-    include_package "net.sf.ehcache"
-    include_package "net.sf.ehcache.config"
+  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
+
+  include_package 'net.sf.ehcache'
+
+  module Config
+    include_package 'net.sf.ehcache.config'
+  end
+
 end

data/lib/ehcache/yaml_config.rb

@@ -0,0 +1,251 @@
+require 'java'
+require 'ehcache'
+require 'yaml'
+require 'erb'
+
+module Ehcache::Config
+  # Support for using YAML for Ehcache configuration.
+  #
+  # <strong>DEPRECATED:</strong> Please use ehcache.xml instead.
+  #
+  # YAML configuration is similar to XML configuration, but there are some
+  # changes to the names of configuration elements to make them simpler or
+  # more idiomatic to Ruby and YAML conventions.  The changes are described
+  # below.  For full documentation on the Ehcache configuration elements,
+  # see the Ehcache Cache Configuration documentation:
+  # http://ehcache.org/documentation/configuration.html
+  #
+  # The top level YAML configuration attributes and the corresponding XML
+  # elements or attributes are shown in the following table.
+  #
+  # name:: name attribute on ehcache element
+  # update_check:: updateCheck attribute on ehcache element
+  # monitoring:: monitoring attribute on ehcache element
+  # dynamic_config:: dynamicConfig attribute on ehcache element
+  # disk_store:: diskStore element
+  # transaction_manager:: transactionManagerLookup element
+  # event_listener:: cacheManagerEventListenerFactory element
+  # peer_providers (Array):: cacheManagerPeerProviderFactory elements
+  # peer_listeners (Array):: cacheManagerPeerListenerFactory elements
+  # terracotta_config:: terracottaConfig element
+  # default_cache:: defaultCache element
+  # caches (Array):: cache elements
+  #
+  # Each top level configuration attribute contains a set of key/value pairs
+  # that are equivalent to the Ehcache XML attributes, except that the
+  # attribute names are converted to use underscore_names instead of
+  # camelCaseNames.  For instance, the Ehcache XML attribute
+  # diskSpoolBufferSizeMB becomes disk_spool_buffer_size_mb in YAML.
+  #
+  # Entries in the above table that are marked as (Array) should be YAML lists
+  # to allow for multiple values.  So, for example, to configure multiple
+  # caches in your YAML configuration, use the following syntax:
+  #
+  #   caches:
+  #     - name: my_cache
+  #       time_to_idle_seconds: 360
+  #       time_to_live_seconds: 1000
+  #     - name: my_other_cache
+  #       max_elements_in_memory: 1000
+  #       eternal: true
+  #       overflow_to_disk: false
+  #       disk_persistent: true
+  #
+  # Note the use of the '-' to separate list elements.
+  #
+  # One further difference between YAML configuration and XML configuration
+  # deals with cache configuration.  The XML configuration allows for a set
+  # of XML sub elements to configure various aspects of caches (or the default
+  # cache).  In YAML, these sub elements are translated to attributes within
+  # the cache configuration (or default_cache configuration) that
+  # refer to Hashes or Arrays.  The following table shows the mapping.
+  #
+  # event_listeners (Array):: cacheEventListenerFactory sub elements
+  # extensions (Array):: cacheExtensionFactory sub elements
+  # loaders (Array):: cacheLoaderFactory sub elements
+  # decorators (Array):: cacheDecoratorFactory sub elements
+  # bootstrap_loader (Hash):: bootstrapCacheLoaderFactory sub element
+  # exception_handler (Hash):: cacheExceptionHandlerFactory sub element
+  # terracotta (Hash):: terracotta sub element
+  # cache_writer (Hash):: cacheWriter sub element
+  # copy_strategy (Hash):: copyStrategy sub element
+  #
+  # Those marked as (Array) may take a list of values, while those marked as
+  # (Hash) may take a single Hash value (set of key/value pairs).  Here is an
+  # example of a cache configuration that uses one of each style:
+  #
+  #   caches:
+  #     - name: some_cache
+  #       time_to_live_seconds: 100
+  #       event_listeners:
+  #         - class: net.sf.ehcache.distribution.RMICacheReplicatorFactory
+  #           properties: "replicateAsynchronously=false"
+  #       copy_strategy:
+  #         class: net.sf.ehcache.store.compound.SerializationCopyStrategy
+  #
+  # Note again the use of the '-' character to separate list elements in the
+  # case of Array values, which is not present for Hash values.
+  module YamlConfig
+
+    InvalidYamlConfiguration = Class.new(StandardError)
+
+    # Not sure why, but "include Java::NetSfEhcacheConfig" does not work,
+    # so define local constants referring to the Ehcache classes
+    Configuration = Java::NetSfEhcacheConfig::Configuration
+    CacheConfiguration = Java::NetSfEhcacheConfig::CacheConfiguration
+    DiskStoreConfiguration = Java::NetSfEhcacheConfig::DiskStoreConfiguration
+    FactoryConfiguration = Java::NetSfEhcacheConfig::FactoryConfiguration
+
+    %w[name update_check monitoring dynamic_config
+       disk_store transaction_manager event_listener
+       peer_providers peer_listeners
+       terracotta_config default_cache caches
+       event_listeners extensions loaders decorators
+    ].each do |attribute|
+      const_set(attribute.upcase.to_sym, attribute)
+    end
+
+    # Parses the given yaml_config_file and returns a corresponding
+    # Ehcache::Config::Configuration object.
+    def self.parse_yaml_config(yaml_config_file)
+      Ehcache::LOG.warn("YAML configuration is deprecated.  Please use ehcache.xml instead.")
+      YamlConfigBuilder.new(yaml_config_file).build
+    end
+
+    private
+
+    class YamlConfigBuilder
+
+      def initialize(yaml_file)
+        @yaml_file = yaml_file
+        @data = YAML.load(ERB.new(File.read(yaml_file)).result(binding))
+        raise InvalidYamlConfiguration unless valid?(@data)
+      end
+
+      def build
+        @config = Configuration.new
+        for attribute in [NAME, UPDATE_CHECK, MONITORING, DYNAMIC_CONFIG]
+          set_if_present(attribute)
+        end
+        set_disk_store
+        set_transaction_manager
+        set_event_listener
+        add_peer_providers
+        add_peer_listeners
+        set_default_cache
+        add_caches
+        @config
+      end
+
+      private
+
+      def valid?(data)
+        data.is_a?(Hash)
+      end
+
+      def set_if_present(key)
+        if @data.has_key?(key)
+          setter = "#{key}=".to_sym
+          @config.send(setter, @data[key])
+        end
+      end
+
+      def set_attributes(object, attributes)
+        attributes ||= []
+        attributes.each do |key, value|
+          if value.is_a?(Hash) || value.is_a?(Array)
+            create_cache_config_factories(object, key, value)
+          else
+            object.send("#{key}=", value)
+          end
+        end
+        object
+      end
+
+      def create_cache_config_factories(cache, key, value)
+        [value].flatten.each do |data|
+          create_cache_config_factory(cache, key, data)
+        end
+      end
+
+      def names_for_factory(key)
+        singular = key.singularize.sub(/s$/, '')
+        factory_name = if key == 'bootstrap_loader'
+          "BootstrapCacheLoaderFactory"
+        else
+          "Cache#{singular.camelize}Factory"
+        end
+        class_name = "#{factory_name}Configuration"
+        method_name = "add#{factory_name}"
+        return [class_name, method_name]
+      end
+
+      def create_cache_config_factory(cache, key, data)
+        class_name, method_name = names_for_factory(key)
+        factory_class = CacheConfiguration.const_get(class_name)
+        factory = factory_class.new
+
+        cache.send(method_name, factory)
+        set_attributes(factory, data)
+      end
+
+      def apply_config(key, config_class)
+        if @data[key]
+          [@data[key]].flatten.each do |data|
+            config = config_class.new
+            set_attributes(config, data)
+            yield config
+          end
+        end
+      end
+
+      def set_disk_store
+        apply_config(DISK_STORE, DiskStoreConfiguration) do |disk_store|
+          @config.add_disk_store(disk_store)
+        end
+      end
+
+      def set_transaction_manager
+        apply_config(TRANSACTION_MANAGER, FactoryConfiguration) do |tx_mgr|
+          @config.add_transaction_manager_lookup(tx_mgr)
+        end
+      end
+
+      def set_event_listener
+        apply_config(EVENT_LISTENER, FactoryConfiguration) do |event_listener|
+          @config.addCacheManagerEventListenerFactory(event_listener)
+        end
+      end
+
+      def add_peer_providers
+        apply_config(PEER_PROVIDERS, FactoryConfiguration) do |peer_provider|
+          @config.addCacheManagerPeerProviderFactory(peer_provider)
+        end
+      end
+
+      def add_peer_listeners
+        apply_config(PEER_LISTENERS, FactoryConfiguration) do |peer_listener|
+          @config.addCacheManagerPeerListenerFactory(peer_listener)
+        end
+      end
+
+      def set_default_cache
+        apply_config(DEFAULT_CACHE, CacheConfiguration) do |cache_config|
+          @config.default_cache_configuration = cache_config
+        end
+      end
+
+      def add_caches
+        apply_config(CACHES, CacheConfiguration) do |cache_config|
+          @config.add_cache(cache_config)
+        end
+      end
+
+      def create_factory_configuration(data)
+        result = FactoryConfiguration.new
+        set_attributes(result, data)
+        result
+      end
+    end
+  end
+end