ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/cache/memcache.rb

@@ -0,0 +1,219 @@
+require 'dalli'
+
+# Kgio gives a nice performance boost but it isn't required
+begin; require 'kgio'; rescue LoadError => e; end
+
+#:nodoc:
+module Ramaze
+  #:nodoc:
+  class Cache
+    ##
+    # Cache driver for the Memcache storage engine. Memcache is a key/value
+    # store that's extremely useful for caching data such as views or API
+    # responses. More information about Memcache can be found on it's website:
+    # <http://memcached.org/>.
+    #
+    # Note that this cache driver requires the Dalli gem rather than Memcache
+    # Client. The reason for this is that the Memcache client hasn't been
+    # updated in over a year and Memcache has changed quite a bit. Dalli is also
+    # supposed to be faster and better coded. This cache driver will also try to
+    # load the kgio Gem if it's installed, if it's not it will just continue to
+    # operate but you won't get the nice speed boost.
+    #
+    # This driver works similar to Ramaze::Cache::Sequel in that it allows you
+    # to specify instance specific options using the using() method:
+    #
+    #     Ramaze::Cache.options.session = Ramaze::Cache::MemCache.using(
+    #       :compression => false
+    #     )
+    #
+    # All options sent to the using() method will be sent to Dalli.
+    #
+    # @example Using the default options
+    #  Ramaze::Cache.options.view = Ramaze::Cache::MemCache
+    #  Ramaze.setup_dependencies
+    #
+    #  Ramaze::Cache.view.store(:my_view, 'Hello Ramaze')
+    #
+    # @example Using custom options
+    #  Ramaze::Cache.options.view = Ramaze::Cache::MemCache.using(
+    #    :compression => false,
+    #    :servers     => ['localhost:11211', 'localhost:112112']
+    #  )
+    #
+    #  Ramaze.setup_dependencies
+    #  Ramaze::Cache.view.store(:my_view, 'Hello Ramaze')
+    #
+    # @author Yorick Peterse
+    # @since  04-05-2011
+    #
+    class MemCache
+      include Cache::API
+      include Innate::Traited
+
+      # The maximum Time To Live that can be used in Memcache
+      MAX_TTL = 2592000
+
+      # Hash containing the default configuration options to use for Dalli
+      trait :default => {
+        # The default TTL for each item
+        :expires_in => 604800,
+
+        # Compresses everything with Gzip if it's over 1K
+        :compress => true,
+
+        # Array containing all default Memcache servers
+        :servers => ['localhost:11211']
+      }
+
+      # Hash containing all the default options merged with the user specified
+      # ones
+      attr_accessor :options
+
+      class << self
+        attr_accessor :options
+
+        ##
+        # This method will create a subclass of Ramaze::Cache::MemCache with all
+        # the custom options set. All options set in this method will be sent to
+        # Dalli as well.
+        #
+        # Using this method allows you to use different memcache settings for
+        # various parts of Ramaze. For example, you might want to use servers A
+        # and B for storing the sessions but server C for only views. Most of
+        # the way this method works was inspired by Ramaze::Cache::Sequel which
+        # was contributed by Lars Olsson.
+        #
+        # @example
+        #  Ramaze::Cache.options.session = Ramaze::Cache::MemCache.using(
+        #    :compression => false,
+        #    :username    => 'ramaze',
+        #    :password    => 'ramaze123',
+        #    :servers     => ['othermachine.com:12345']
+        #  )
+        #
+        # @author Yorick Peterse
+        # @since  04-05-2011
+        # @param  [Hash] options A hash containing all configuration options to
+        #  use for Dalli. For more information on all the available options you
+        #  can read the README in their repository. This repository can be found
+        #  here: https://github.com/mperham/dalli
+        #
+        def using(options = {})
+          merged = Ramaze::Cache::MemCache.trait[:default].merge(options)
+          Class.new(self) { @options = merged }
+        end
+      end # class << self
+
+      ##
+      # Creates a new instance of the cache class.
+      #
+      # @author Michael Fellinger
+      # @since  04-05-2011
+      # @param  [Hash] options A hash with custom options, see
+      #  Ramaze::Cache::MemCache.using for all available options.
+      #
+      def initialize(options = {})
+        self.class.options ||= Ramaze::Cache::MemCache.trait[:default].merge(
+          options
+        )
+
+        @options = options.merge(self.class.options)
+      end
+
+      ##
+      # Prepares the cache by creating the namespace and an instance of a Dalli
+      # client.
+      #
+      # @author Yorick Peterse
+      # @since  04-05-2011
+      # @param  [String] hostname  The hostname of the machine running the
+      #  application.
+      # @param  [String] username  The name of the user executing the process
+      # @param  [String] appname   Unique identifier for the application.
+      # @param  [String] cachename The namespace to use for this cache instance.
+      #
+      def cache_setup(hostname, username, appname, cachename)
+        # Validate the maximum TTL
+        if options[:expires_in] > MAX_TTL
+          raise(ArgumentError, "The maximum TTL of Memcache is 30 days")
+        end
+
+        options[:namespace] = [
+          hostname, username, appname, cachename
+        ].compact.join('-')
+
+        @client = ::Dalli::Client.new(options[:servers], options)
+      end
+
+      ##
+      # Removes all items from the cache.
+      #
+      # @author Yorick Peterse
+      # @since  04-05-2011
+      #
+      def cache_clear
+        @client.flush
+      end
+
+      ##
+      # Removes the specified keys from the cache.
+      #
+      # @author Yorick Peterse
+      # @since  04-05-2011
+      # @param  [Array] keys The keys to remove from the cache.
+      #
+      def cache_delete(*keys)
+        keys.each do |key|
+          @client.delete(key)
+        end
+      end
+
+      ##
+      # Fetches the specified key from the cache. It the value was nil the
+      # default value will be returned instead.
+      #
+      # @author Yorick Peterse
+      # @since  04-05-2011
+      # @param  [String] key The name of the key to retrieve.
+      # @param  [Mixed] default The default value.
+      # @return [Mixed]
+      #
+      def cache_fetch(key, default = nil)
+        value = @client.get(key)
+
+        if value.nil?
+          return default
+        else
+          return value
+        end
+      end
+
+      ##
+      # Sets the given key to the specified value. Optionally you can specify a
+      # hash with options specific to the key. Once a key has been stored it's
+      # value will be returned.
+      #
+      # @author Yorick Peterse
+      # @since  04-05-2011
+      # @param  [String] key The name of the key to store.
+      # @param  [Mixed] value The value to store in Memcache.
+      # @param  [Fixnum] ttl The Time To Live to use for the current key.
+      # @param  [Hash] options A hash containing options specific for the
+      #  specified key.
+      # @return [Mixed]
+      #
+      def cache_store(key, value, options = {})
+        ttl = options.delete(:ttl) || @options[:expires_in]
+
+        if ttl > MAX_TTL
+          raise(ArgumentError, "The maximum TTL of Memcache is 30 days")
+        end
+
+        @client.set(key, value, ttl, options)
+
+        return value
+      end
+    end # MemCache
+  end # Cache
+end # Ramaze

data/lib/ramaze/cache/moneta.rb

@@ -0,0 +1,143 @@
+require 'moneta'
+
+module Ramaze
+  class Cache
+    ##
+    # The Moneta cache is a cache driver for Moneta (http://github.com/minad/moneta). Moneta is a
+    # unified interface to key/value stores.
+    #
+    # The usage of this cache is very similar to the Memcache driver. You load
+    # it by simply specifying the class:
+    #
+    #     Ramaze::Cache.options.session = Ramaze::Cache::Moneta
+    #
+    # If you want to specify custom options you can do so by calling {.using} on
+    # the class:
+    #
+    #     Ramaze::Cache.options.session = Ramaze::Cache::Moneta.using(...)
+    #
+    # @example Configuring the Moneta backend
+    #  Ramaze::Cache.options.names.push(:moneta)
+    #  Ramaze::Cache.options.moneta = Ramaze::Cache::Moneta.using(
+    #    :adapter => :File,
+    #    :dir => './ramaze-cache'
+    #  )
+    #
+    # @author Daniel Mendler
+    #
+    class Moneta
+      include Cache::API
+      include Innate::Traited
+
+      # Hash containing all the default options to use when no custom ones are
+      # specified in .using().
+      trait :default => {
+        :expires_in => 604800,
+        :adapter => :Memory,
+      }
+
+      # Hash containing all the default options merged with the user specified
+      # ones.
+      attr_accessor :options
+
+      class << self
+        attr_accessor :options
+
+        ##
+        # Creates a new instance of the cache class and merges the default
+        # options with the custom ones.
+        #
+        # Using this method you can specify custom options for various caches.
+        # For example, the Moneta cache for your sessions could be located at
+        # server #1 while a custom cache is located on server #2.
+        #
+        # @author Daniel Mendler
+        # @param  [Hash] options A hash containing custom options.
+        # @option options [Fixnum] :expires_in The default time after which a
+        #  key should expire.
+        # @option options [Symbol] :adapter Moneta adapter
+        #
+        def using(options = {})
+          merged = Ramaze::Cache::Moneta.trait[:default].merge(options)
+          Class.new(self) { @options = merged }
+        end
+      end # class << self
+
+      ##
+      # Creates a new instance of the cache and merges the options if they
+      # haven't already been set.
+      #
+      # @author Daniel Mendler
+      # @param  [Hash] options A hash with custom options. See
+      #  Ramaze::Cache::Moneta.using() and the trait :default for more
+      #  information.
+      #
+      def initialize(options = {})
+        self.class.options ||=
+          Ramaze::Cache::Moneta.trait[:default].merge(options)
+
+        @options = options.merge(self.class.options)
+      end
+
+      ##
+      # Prepares the cache by setting up the prefix and loading Moneta.
+      #
+      # @author Daniel Mendler
+      #
+      def cache_setup(*args)
+        opts = options.dup
+        opts[:prefix] = ['ramaze', *args].compact.join(':')
+        opts[:expires] = opts.delete(:expires_in)
+        adapter = opts.delete(:adapter)
+        @moneta = ::Moneta.new(adapter, options)
+      end
+
+      ##
+      # Clears the entire cache.
+      #
+      # @author Daniel Mendler
+      #
+      def cache_clear
+        @moneta.clear
+      end
+
+      ##
+      # Removes a number of keys from the cache.
+      #
+      # @author Daniel Mendler
+      # @param  [Array] keys An array of key names to remove.
+      #
+      def cache_delete(*keys)
+        keys.each {|key| @moneta.delete(key) }
+      end
+
+      ##
+      # Retrieves the value of the given key. If no value could be retrieved the
+      # default value (set to nil by default) will be returned instead.
+      #
+      # @author Daniel Mendler
+      # @param  [String] key The name of the key to retrieve.
+      # @param  [Mixed] default The default value.
+      # @return [Mixed]
+      #
+      def cache_fetch(key, default = nil)
+        @moneta.fetch(key, default)
+      end
+
+      ##
+      # Stores a new value under the given key.
+      #
+      # @author Daniel Mendler
+      # @param  [String] key The name of the key to store.
+      # @param  [Mixed] value The value of the key.
+      # @param  [Fixnum] ttl The Time To Live of the key.
+      # @param  [Hash] options A hash containing key specific options.
+      # @option options :expires_in The time after which the key should expire.
+      #
+      def cache_store(key, value, options = {})
+        options[:expires] = options.delete(:ttl) || @options[:expires_in]
+        @moneta.store(key, value, options)
+      end
+    end # Moneta
+  end # Cache
+end # Ramaze

data/lib/ramaze/cache/redis.rb

@@ -0,0 +1,163 @@
+require 'redis-namespace'
+
+module Ramaze
+  class Cache
+    ##
+    # The Redis cache is a cache driver for Redis (http://redis.io/). Redis is a
+    # key/value store similar to Memcached but with the ability to flush data to
+    # a file among various other features.
+    #
+    # The usage of this cache is very similar to the Memcache driver. You load
+    # it by simply specifying the class:
+    #
+    #     Ramaze::Cache.options.session = Ramaze::Cache::Redis
+    #
+    # If you want to specify custom options you can do so by calling {.using} on
+    # the class:
+    #
+    #     Ramaze::Cache.options.session = Ramaze::Cache::Redis.using(...)
+    #
+    # @example Using a custom Redis host
+    #  Ramaze::Cache.options.names.push(:redis)
+    #  Ramaze::Cache.options.redis = Ramaze::Cache::Redis.using(
+    #    :host => '123.124.125.126',
+    #    :port => 6478
+    #  )
+    #
+    # @author Michael Fellinger
+    # @since  09-10-2011
+    #
+    class Redis
+      include Cache::API
+      include Innate::Traited
+
+      # Hash containing all the default options to use when no custom ones are
+      # specified in .using().
+      trait :default => {
+        :expires_in => 604800,
+        :host       => 'localhost',
+        :port       => 6379
+      }
+
+      # Hash containing all the default options merged with the user specified
+      # ones.
+      attr_accessor :options
+
+      class << self
+        attr_accessor :options
+
+        ##
+        # Creates a new instance of the cache class and merges the default
+        # options with the custom ones.
+        #
+        # Using this method you can specify custom options for various caches.
+        # For example, the Redis cache for your sessions could be located at
+        # server #1 while a custom cache is located on server #2.
+        #
+        # @author Yorick Peterse
+        # @since  09-10-2011
+        # @param  [Hash] options A hash containing custom options.
+        # @option options [Fixnum] :expires_in The default time after which a
+        #  key should expire.
+        # @option options [String] :host The hostname of the machine on which
+        #  Redis is running.
+        # @option options [Fixnum] :port The port number to connect to.
+        #
+        def using(options = {})
+          merged = Ramaze::Cache::Redis.trait[:default].merge(options)
+          Class.new(self) { @options = merged }
+        end
+      end # class << self
+
+      ##
+      # Creates a new instance of the cache and merges the options if they
+      # haven't already been set.
+      #
+      # @author Michael Fellinger
+      # @param  [Hash] options A hash with custom options. See
+      #  Ramaze::Cache::Redis.using() and the trait :default for more
+      #  information.
+      #
+      def initialize(options = {})
+        self.class.options ||=
+          Ramaze::Cache::Redis.trait[:default].merge(options)
+
+        @options = options.merge(self.class.options)
+      end
+
+      ##
+      # Prepares the cache by setting up the namespace and loading Redis.
+      #
+      # @author Michael Fellinger
+      # @since  09-10-2011
+      # @param  [String] hostname The host of the machine that's running the
+      #  Ramaze application.
+      # @param  [String] username The name of the user that's running the
+      #  application.
+      # @param  [String] appname The name of the application (:pristine by
+      #  default).
+      # @param  [String] cachename The namespace to use for this cache instance.
+      #
+      def cache_setup(hostname, username, appname, cachename)
+        options[:namespace] = [
+          'ramaze', hostname, username, appname, cachename
+        ].compact.join(':')
+        redis_connection = ::Redis.new
+        @client = ::Redis::Namespace.new(options[:namespace], redis: redis_connection)
+      end
+
+      ##
+      # Clears the entire cache.
+      #
+      # @author Michael Fellinger
+      # @since  09-10-2011
+      #
+      def cache_clear
+        @client.flushall
+      end
+
+      ##
+      # Removes a number of keys from the cache.
+      #
+      # @author Michael Fellinger
+      # @param  [Array] keys An array of key names to remove.
+      #
+      def cache_delete(*keys)
+        @client.del(*keys)
+      end
+
+      ##
+      # Retrieves the value of the given key. If no value could be retrieved the
+      # default value (set to nil by default) will be returned instead.
+      #
+      # @author Michael Fellinger
+      # @param  [String] key The name of the key to retrieve.
+      # @param  [Mixed] default The default value.
+      # @return [Mixed]
+      #
+      def cache_fetch(key, default = nil)
+        value = @client.get(key)
+        value.nil? ? default : ::Marshal.load(value)
+      end
+
+      ##
+      # Stores a new value under the given key.
+      #
+      # @author Michael Fellinger
+      # @param  [String] key The name of the key to store.
+      # @param  [Mixed] value The value of the key.
+      # @param  [Fixnum] ttl The Time To Live of the key.
+      # @param  [Hash] options A hash containing key specific options.
+      # @option options :expires_in The time after which the key should expire.
+      #
+      def cache_store(key, value, options = {})
+        ttl = options[:ttl] || @options[:expires_in]
+
+        @client.setex(key, ttl, ::Marshal.dump(value))
+
+        return value
+      end
+      
+    end # Redis
+  end # Cache
+end # Ramaze