torquebox-caching 4.0.0.alpha1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e27cd0727836afa968aea5b75379557c9429cec
+  data.tar.gz: 7f1ab4734d94126d0084f3b02a8bdbb07acecc72
+SHA512:
+  metadata.gz: c1e062ff99f81243df3e3bc0d26aa376b725fc72179ebe573907b899d1e6349c3b09177b61df39432819334ab3ed4e36488d0af7c5cd73820032c2985b25ab33
+  data.tar.gz: 47bb70cf25ff0f336dabc59ed3a1ab83c930bfe43dc827ade899750f8087bab86d7758d61e36d43eb6fb4c3675fa8782c55d5f9788fef4a518b9586cc686780d

data/lib/active_support/cache/torque_box_store.rb

@@ -0,0 +1,111 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'active_support/cache'
+require 'torquebox/caching'
+
+# @api private
+module ActiveSupport
+  module Cache
+    # @api public
+    class TorqueBoxStore < Store
+
+      def initialize(options = {})
+        if (ttl = options.delete(:expires_in))
+          options[:ttl] = ttl.in_milliseconds
+        end
+        @name = options.delete(:name) || '__torquebox_store__'
+        super(options)
+        cache
+      end
+
+      # Clear the entire cache. Be careful with this method since it could
+      # affect other processes if shared cache is being used.
+      def clear(_options = nil)
+        cache.clear
+      end
+
+      # Delete all entries with keys matching the pattern.
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        pattern = key_matcher(matcher, options)
+        keys.each { |key| delete(key, options) if key =~ pattern }
+      end
+
+      # Increment an integer value in the cache; return new value
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+
+        # Get the current entry
+        key = namespaced_key(name, options)
+        current = read_entry(key, options)
+        value = current.value.to_i
+
+        new_entry = Entry.new(value + amount, options)
+        if cache.compare_and_set(key, current, new_entry)
+          return new_entry.value
+        else
+          raise "Concurrent modification, old value was #{value}"
+        end
+      end
+
+      # Decrement an integer value in the cache; return new value
+      def decrement(name, amount = 1, options = nil)
+        increment(name, -amount, options)
+      end
+
+      # Cleanup the cache by removing expired entries.
+      def cleanup(options = nil)
+        options = merged_options(options)
+        keys.each do |key|
+          entry = read_entry(key, options)
+          delete_entry(key, options) if entry && entry.expired?
+        end
+      end
+
+      protected
+
+      def defaults
+        { :mode => :invalidation_async }
+      end
+
+      # Return the keys in the cache; potentially very expensive depending on configuration
+      def keys
+        cache.keys
+      end
+
+      # Read an entry from the cache implementation. Subclasses must implement this method.
+      def read_entry(key, _options)
+        cache.get(key)
+      end
+
+      # Write an entry to the cache implementation. Subclasses must implement this method.
+      def write_entry(key, entry, options = {})
+        options[:unless_exist] ? cache.put_if_absent(key, entry) : cache.put(key, entry)
+      end
+
+      # Delete an entry from the cache implementation. Subclasses must implement this method.
+      def delete_entry(key, _options) # :nodoc:
+        cache.remove(key) && true
+      end
+
+
+      private
+
+      def cache
+        @cache ||= TorqueBox::Caching.cache(@name, defaults.merge(options))
+      end
+    end
+  end
+end

data/lib/active_support/cache/torquebox_store.rb

@@ -0,0 +1,2 @@
+# This assignment allows :torquebox_store to work as a symbol
+ActiveSupport::Cache::TorqueboxStore = ActiveSupport::Cache::TorqueBoxStore

data/lib/torquebox/caching/cache.rb

@@ -0,0 +1,336 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'forwardable'
+
+java_import java.util.concurrent::TimeUnit
+java_import org.projectodd.wunderboss.caching.notifications::Listener
+
+module TorqueBox
+  module Caching
+    class Cache
+      extend Forwardable
+
+      # Wraps a real Infinispan cache object with a slightly simpler
+      # interface. The wrapped cache is available via the {#cache}
+      # accessor.
+      #
+      # @param cache [org.infinispan.Cache] The wrapped cache
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      def initialize(cache, options = {})
+        @cache = cache
+        @options = options
+      end
+
+      # Associate key to value in the cache. Expiration options
+      # override any passed to the constructor.
+      #
+      # @param key [Object]
+      # @param value [Object]
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      # @return [Object] the old value, if any
+      def put(key, value, options = {})
+        put_m.call(*[key, value] + expiry(options))
+      end
+
+      # Put a map of entries into the cache. Expiration options
+      # override any passed to the constructor.
+      #
+      # @param map [Hash]
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      # @return [void]
+      def put_all(map, options = {})
+        putall_m.call(*[map] + expiry(options))
+      end
+
+      # Associate key to value only if key doesn't exist in cache.
+      # Expiration options override any passed to the constructor.
+      #
+      # @param key [Object]
+      # @param value [Object]
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      # @return [Object] nil on success, otherwise the old value
+      def put_if_absent(key, value, options = {})
+        putif_m.call(*[key, value] + expiry(options))
+      end
+
+      # Associate key to value only if key exists in cache. Expiration
+      # options override any passed to the constructor.
+      #
+      # @param key [Object]
+      # @param value [Object]
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      # @return [Object] the old value on success, otherwise nil
+      def replace(key, value, options = {})
+        replace_m.call(*[key, value] + expiry(options))
+      end
+
+      # Associate key to a new value only if it's currently mapped to
+      # a specific value. Expiration options override any passed to
+      # the constructor.
+      #
+      # @param key [Object] the key
+      # @param old_value [Object] the current value of the key
+      # @param new_value [Object] the desired value of the key
+      # @param options [Hash] Options for entry expiration
+      # @option options :ttl [Number] (-1) milliseconds the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) milliseconds after which an
+      #   entry will expire if not accessed
+      # @return [true, false] true if value successfully replaced
+      def compare_and_set(key, old_value, new_value, options = {})
+        cas_m.call(*[key, old_value, new_value] + expiry(options))
+      end
+
+      # Clear all entries from the cache
+      #
+      # @return [void]
+      def clear
+        @cache.clear
+        self
+      end
+
+      # Infinispan's cache notifications API is based on Java
+      # annotations, which can be awkward in JRuby (and Java, for that
+      # matter).
+      #
+      # This function provides the ability to map one or more symbols
+      # to a block that will be passed an
+      # {https://docs.jboss.org/infinispan/6.0/apidocs/org/infinispan/notifications/cachelistener/event/package-summary.html
+      # Infinispan Event} instance.
+      #
+      # Each symbol corresponds to an event type, i.e. one of the
+      # {http://docs.jboss.org/infinispan/6.0/apidocs/org/infinispan/notifications/cachelistener/annotation/package-summary.html
+      # Infinispan annotations}:
+      #
+      #  - :cache_entries_evicted
+      #  - :cache_entry_activated
+      #  - :cache_entry_created
+      #  - :cache_entry_invalidated
+      #  - :cache_entry_loaded
+      #  - :cache_entry_modified
+      #  - :cache_entry_passivated
+      #  - :cache_entry_removed
+      #  - :cache_entry_visited
+      #  - :data_rehashed
+      #  - :topology_changed
+      #  - :transaction_completed
+      #  - :transaction_registered
+      #
+      # The callbacks are synchronous, i.e. invoked on the thread acting on
+      # the cache. For longer running callbacks, use a queue or some sort of
+      # asynchronous channel.
+      #
+      # The return value is an array of listener objects corresponding
+      # to the requested event types, which will be a subset of those
+      # returned from the {get_listeners} method. These may be passed
+      # to the {remove_listener} method to turn off notifications.
+      def add_listener(*types, &block)
+        handler = Handler.new(block)
+        listeners = types.map { |type| Listener::listen(handler, type.to_s) }
+        listeners.each { |listener| @cache.add_listener(listener) }
+      end
+
+      # @!method get(key)
+      #
+      # Get the value associated with the key
+      #
+      # @return [Object] nil if missing
+      def_delegators :@cache, :get
+
+      # @!method size()
+      #
+      # Get the number of entries in the cache
+      #
+      # @return [Fixnum]
+      def_delegators :@cache, :size
+
+      # @!method empty?()
+      #
+      # Return true if cache contains no entries
+      #
+      # @return [true, false]
+      def_delegators :@cache, :empty?
+
+      # @!method entry_set()
+      #
+      # Return a Set of Map.Entry instances
+      #
+      # @return [Set]
+      def_delegators :@cache, :entry_set
+
+      # @!method contains_key?(key)
+      #
+      # Return true if cache contains the key
+      #
+      # @return [true, false]
+      def_delegators :@cache, :contains_key?
+
+      # @!method evict(key)
+      #
+      # Remove entry from the heap, but not persistent storage, so
+      # subsequent reads will cause it to be reloaded
+      #
+      # @return [void]
+      def_delegators :@cache, :evict
+
+      # @!method remove(key)
+      #
+      # Remove the entry associated with the key
+      #
+      # @return [Object] the old value or nil, if key is missing
+      def_delegators :@cache, :remove
+
+      # @!method values()
+      #
+      # Get the values in the cache
+      #
+      # @return [Array]
+      def_delegators :@cache, :values
+
+      # @!method keys()
+      #
+      # Get the keys in the cache
+      #
+      # @return [Array]
+      def_delegators :@cache, :keys
+
+      # @!method name()
+      #
+      # Get cache name
+      #
+      # @return [String]
+      def_delegators :@cache, :name
+
+      # @!method get_listeners()
+      #
+      # Get the cache's active event listener instances
+      #
+      # @return [Array]
+      def_delegators :@cache, :get_listeners
+
+      # @!method remove_listener(listener)
+      #
+      # Turn off a particular event listener
+      #
+      # @return [void]
+      def_delegators :@cache, :remove_listener
+
+      # @!method configuration()
+      #
+      # Get the cache's configuration instance
+      #
+      # @return [org.infinispan.configuration.cache.Configuration]
+      def_delegator :@cache, :cache_configuration, :configuration
+
+      # @!method cache()
+      #
+      # Accessor for the wrapped cache instance
+      #
+      # @return [org.infinispan.Cache]
+      attr_accessor :cache
+
+      def_delegators :@cache, :[], :[]=
+
+
+      private
+
+      def defaults(options)
+        { :ttl => -1, :idle => -1 }.merge(@options).merge(options)
+      end
+
+      def expiry(options)
+        m = defaults(options)
+        [m[:ttl], TimeUnit::MILLISECONDS, m[:idle], TimeUnit::MILLISECONDS]
+      end
+
+      class Handler
+        include Java::OrgProjectoddWunderbossCachingNotifications::Handler
+        def initialize(block)
+          @block = block
+        end
+
+        def handle(event)
+          @block.call(event)
+        end
+      end
+
+      def replace_m
+        @replace_m ||= @cache.java_method(:replace, [java.lang.Object,
+                                                     java.lang.Object,
+                                                     Java::long,
+                                                     java.util.concurrent.TimeUnit,
+                                                     Java::long,
+                                                     java.util.concurrent.TimeUnit])
+      end
+
+      def cas_m
+        @cas_m ||= @cache.java_method(:replace, [java.lang.Object,
+                                                 java.lang.Object,
+                                                 java.lang.Object,
+                                                 Java::long,
+                                                 java.util.concurrent.TimeUnit,
+                                                 Java::long,
+                                                 java.util.concurrent.TimeUnit])
+      end
+
+      def put_m
+        @put_m ||= @cache.java_method(:put, [java.lang.Object,
+                                             java.lang.Object,
+                                             Java::long,
+                                             java.util.concurrent.TimeUnit,
+                                             Java::long,
+                                             java.util.concurrent.TimeUnit])
+      end
+
+      def putall_m
+        @putall_m ||= @cache.java_method(:putAll, [java.util.Map.java_class,
+                                                   Java::long,
+                                                   java.util.concurrent.TimeUnit,
+                                                   Java::long,
+                                                   java.util.concurrent.TimeUnit])
+      end
+
+      def putif_m
+        @putif_m ||= @cache.java_method(:putIfAbsent, [java.lang.Object,
+                                                       java.lang.Object,
+                                                       Java::long,
+                                                       java.util.concurrent.TimeUnit,
+                                                       Java::long,
+                                                       java.util.concurrent.TimeUnit])
+      end
+
+    end
+  end
+end

data/lib/torquebox/caching.rb

@@ -0,0 +1,138 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'torquebox/codecs'
+require 'torquebox/caching/cache'
+
+module TorqueBox
+  module Caching
+    class << self
+      include OptionUtils
+      extend OptionUtils
+      java_import org.projectodd.wunderboss::WunderBoss
+      java_import org.projectodd.wunderboss::Options
+      java_import org.projectodd.wunderboss.caching::Caching
+      VALID_OPTIONS = optset(Caching::CreateOption, :encoding)
+
+      # Returns an
+      # {https://docs.jboss.org/infinispan/6.0/apidocs/org/infinispan/Cache.html
+      # org.infinispan.Cache}, an extension of
+      # `java.util.concurrent.ConcurrentMap`. A name is the only
+      # required argument. If a cache by that name already exists, it
+      # will be returned, and any options passed to this function will
+      # be ignored. To force reconfiguration of an existing cache,
+      # call {stop} before calling this function.
+      #
+      # *Durability:* Entries can persist to disk via the :persist
+      # option. If set to `true`, cache entries will persist in the
+      # current directory. Override this by setting `:persist` to a
+      # string naming the desired directory.
+      #
+      # *Eviction:* Turned off by default, `:max_entries` may be set to
+      # mitigate the risk of memory exhaustion. When `:persist` is
+      # enabled, evicted entries are written to disk, so that the
+      # entries in memory are a subset of those in the file store,
+      # transparently reloaded upon request. The eviction policy may
+      # be one of `:none`, `:lru`, `:lirs`, or `:unordered`
+      #
+      # *Expiration:* Both time-to-live and max idle limits are
+      # supported. Units are milliseconds.
+      #
+      # *Replication:* The replication mode defaults to `:dist_sync` when
+      # clustered. When not clustered, the value of `:mode` is ignored,
+      # and the cache will be `:local`. Asynchronous replication may
+      # yield a slight performance increase at the risk of potential
+      # cache inconsistency.
+      #
+      # *Transactions:* Caches can participate in transactions when a
+      # TransactionManager is available. The locking scheme may be
+      # either `:optimisitic` or `:pessimistic`
+      #
+      # *Advanced configuration:* Infinispan has many buttons,
+      # switches, dials, knobs and levers. Call the {builder} function
+      # to create your own Configuration instance and pass it in via
+      # the `:configuration` option.
+      #
+      # @param name [String] The name of the cache
+      # @param options [Hash] Options for cache creation.
+      # @option options :persist [String, true, false] (nil) if non-nil,
+      #   data persists across server restarts in a file store; a
+      #   string value names the directory
+      # @option options :max_entries [Number] (-1) the max number of
+      #   entries allowed in the cache
+      # @option options :eviction [Symbol] (:none) how entries are
+      #   evicted when :max_entries is exceeded
+      # @option options :ttl [Number] (-1) the max time the entry will
+      #   live before expiry
+      # @option options :idle [Number] (-1) the time after which an
+      #   entry will expire if not accessed
+      # @option options :mode [Symbol] (:dist_sync or :local)
+      #   replication mode, one of :local, :repl_sync, :repl_async,
+      #   :invalidation_sync, :invalidation_async, :dist_sync,
+      #   :dist_async
+      # @option options :transactional [true, false] (false) whether
+      #   the cache is transactional
+      # @option options :locking [Symbol] (:optimistic) transactional
+      #   locking scheme
+      # @option options :encoding [Symbol] (:marshal_smart) other
+      #   supported encodings include :edn, :json, :marshal,
+      #   :marshal_base64 and :text
+      # @option options :configuration [Configuration] a
+      #   {https://docs.jboss.org/infinispan/6.0/apidocs/org/infinispan/configuration/cache/Configuration.html
+      #   Configuration} instance
+      # @return [Cache] The cache reference
+      def cache(name, options = {})
+        validate_options(options, VALID_OPTIONS)
+        cache = component.find_or_create(name, extract_options(options, Caching::CreateOption))
+        codec = Codecs[options.fetch(:encoding, :marshal_smart)]
+        Cache.new(component.withCodec(cache, codec), options)
+      end
+
+      # Stop cache by name
+      #
+      # @param name [String] the name of the cache to stop
+      # @return [true, false] true if successfully stopped
+      def stop(name)
+        component.stop(name)
+      end
+
+      # Determine whether cache is currently running
+      #
+      # @param name [String] the name of the cache
+      # @return [true, false] true if running
+      def exists?(name)
+        !!component.find(name)
+      end
+
+      # For advanced use, call this function to obtain a "fluent"
+      # {https://docs.jboss.org/infinispan/6.0/apidocs/org/infinispan/configuration/cache/ConfigurationBuilder.html
+      # ConfigurationBuilder}.
+      # Set the desired options, and invoke its build method, the
+      # result from which can be passed via the :configuration option
+      # of the {cache} function.
+      #
+      # Note that builder takes the same options as {cache}
+      def builder(options = {})
+        config = org.projectodd.wunderboss.caching::Config
+        config.builder(Options.new(extract_options(options, Caching::CreateOption)))
+      end
+
+      private
+
+      def component
+        @component ||= WunderBoss.find_or_create_component(Caching.java_class)
+      end
+    end
+  end
+end

data/lib/torquebox-caching.rb

@@ -0,0 +1,21 @@
+# Copyright 2014 Red Hat, Inc, and individual contributors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'torquebox-core'
+
+Dir.glob("#{File.dirname(__FILE__)}/wunderboss-jars/*.jar") do |jar|
+  TorqueBox::Jars.register_and_require(jar)
+end
+
+require 'torquebox/caching'

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: torquebox-caching
+version: !ruby/object:Gem::Version
+  version: 4.0.0.alpha1
+platform: java
+authors:
+- The TorqueBox Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: torquebox-core
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.alpha1
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.alpha1
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: jbundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  prerelease: false
+  type: :development
+description:
+email: torquebox-dev@torquebox.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/torquebox-caching.rb
+- lib/torquebox/caching.rb
+- lib/torquebox/caching/cache.rb
+- lib/active_support/cache/torquebox_store.rb
+- lib/active_support/cache/torque_box_store.rb
+- lib/wunderboss-jars/jboss-transaction-api_1.1_spec-1.0.1.Final.jar
+- lib/wunderboss-jars/wunderboss-caching-1.x.incremental.174.jar
+- lib/wunderboss-jars/infinispan-commons-6.0.2.Final.jar
+- lib/wunderboss-jars/infinispan-core-6.0.2.Final.jar
+- lib/wunderboss-jars/jboss-marshalling-river-1.4.4.Final.jar
+- lib/wunderboss-jars/jboss-marshalling-1.4.4.Final.jar
+homepage: http://torquebox.org/torqbox
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements:
+- jar org.projectodd.wunderboss:wunderboss-ruby, 1.x.incremental.174
+- jar org.projectodd.wunderboss:wunderboss-caching, 1.x.incremental.174
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: TorqueBox Next Generation
+test_files: []
+has_rdoc: