thoughtless-moneta 0.6.0.1 → 0.6.0.2

data/lib/moneta/file.rb

@@ -1,91 +0,0 @@
-begin
-  require "xattr"
-rescue LoadError
-  puts "You need the xattr gem to use the File moneta store"
-  exit
-end
-require "fileutils"
-
-module Moneta
-  class File
-    class Expiration
-      def initialize(directory)
-        @directory = directory
-      end
-      
-      def [](key)
-        attrs = xattr(key)
-        ret = Marshal.load(attrs.get("moneta_expires"))
-      rescue Errno::ENOENT, SystemCallError
-      end
-      
-      def []=(key, value)
-        attrs = xattr(key)
-        attrs.set("moneta_expires", Marshal.dump(value))
-      end
-      
-      def delete(key)
-        attrs = xattr(key)
-        attrs.remove("moneta_expires")
-      end
-
-      private
-      def xattr(key)
-        ::Xattr.new(::File.join(@directory, key))
-      end
-    end
-    
-    def initialize(options = {})
-      @directory = options[:path]
-      if ::File.file?(@directory)
-        raise StandardError, "The path you supplied #{@directory} is a file"
-      elsif !::File.exists?(@directory)
-        FileUtils.mkdir_p(@directory)
-      end
-      
-      @expiration = Expiration.new(@directory)
-    end
-    
-    module Implementation
-      def key?(key)
-        ::File.exist?(path(key))
-      end
-      
-      alias has_key? key?
-      
-      def [](key)
-        if ::File.exist?(path(key))
-          Marshal.load(::File.read(path(key)))
-        end
-      end
-      
-      def []=(key, value)
-        ::File.open(path(key), "w") do |file|
-          contents = Marshal.dump(value)
-          file.puts(contents)
-        end
-      end
-            
-      def delete(key)
-        value = self[key]
-        FileUtils.rm(path(key))
-        value
-      rescue Errno::ENOENT
-      end
-            
-      def clear
-        FileUtils.rm_rf(@directory)
-        FileUtils.mkdir(@directory)
-      end
-      
-      private
-      def path(key)
-        ::File.join(@directory, key.to_s)
-      end
-    end
-    include Implementation
-    include Defaults
-    include Expires
-    
-  end
-end

data/lib/moneta/lmc.rb

@@ -1,52 +0,0 @@
-begin
-  require "localmemcache"
-rescue LoadError
-  puts "You need the localmemcache gem to use the LMC moneta store"
-  exit
-end
-
-module Moneta
-  class Expiration
-    def initialize(hash)
-      @hash = hash
-    end
-    
-    def [](key)         @hash["#{key}__!__expiration"]          end
-    def []=(key, value) @hash["#{key}__!__expiration"] = value  end
-      
-    def delete(key)
-      key = "#{key}__!__expiration"
-      value = @hash[key]
-      @hash.delete(key)
-      value
-    end
-  end
-  
-  class LMC
-    include Defaults
-
-    module Implementation
-      def initialize(options = {})
-        @hash = LocalMemCache.new(:filename => options[:filename])
-        @expiration = Expiration.new(@hash)
-      end    
-
-      def [](key)         @hash[key]          end
-      def []=(key, value) @hash[key] = value  end
-      def clear()         @hash.clear         end
-
-      def key?(key)
-        @hash.keys.include?(key)
-      end
-
-      def delete(key)
-        value = @hash[key]
-        @hash.delete(key)
-        value
-      end      
-    end
-    include Implementation
-    include StringExpires
-   
-  end
-end

data/lib/moneta/memcache.rb

@@ -1,53 +0,0 @@
-begin
-  require "memcached"
-  MemCache = Memcached
-rescue LoadError
-  require "memcache"
-rescue
-  puts "You need either the `memcached` or `memcache-client` gem to use the Memcache moneta store"
-  exit
-end
-
-module Moneta
-  class Memcache
-    include Defaults
-    
-    def initialize(options = {})
-      @cache = MemCache.new(options.delete(:server), options)
-    end
-
-    def key?(key)
-      !self[key].nil?
-    end
-
-    alias has_key? key?
-
-    def [](key)
-      @cache.get(key)
-    end
-
-    def []=(key, value)
-      store(key, value)
-    end
-
-    def delete(key)
-      value = self[key]
-      @cache.delete(key) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      args = [key, value, options[:expires_in]].compact
-      @cache.set(*args)
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    end
-
-    def clear
-      @cache.flush_all
-    end
-  end
-end

data/lib/moneta/memory.rb

@@ -1,11 +0,0 @@
-module Moneta
-  class Memory < Hash
-    include Expires
-    
-    def initialize(*args)
-      @expiration = {}
-      super
-    end    
-        
-  end
-end

data/lib/moneta/mongodb.rb

@@ -1,58 +0,0 @@
-begin
-  require "mongo"
-rescue LoadError
-  puts "You need the mongo gem to use the MongoDB moneta store"
-  exit
-end
-
-module Moneta
-  class MongoDB
-    include Defaults
-    
-    def initialize(options = {})
-      options = {
-        :host => ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-        :port => ENV['MONGO_RUBY_DRIVER_PORT'] || XGen::Mongo::Driver::Mongo::DEFAULT_PORT,
-        :db => 'cache',
-        :collection => 'cache'
-      }.update(options)
-      conn = XGen::Mongo::Driver::Connection.new(options[:host], options[:port])
-      @cache = conn.db(options[:db]).collection(options[:collection])
-    end
-
-    def key?(key)
-      !!self[key]
-    end
-
-    def [](key)
-      res = @cache.find_first('_id' => key)
-      res = nil if res && res['expires'] && Time.now > res['expires']
-      res && res['data']
-    end
-
-    def []=(key, value)
-      store(key, value)
-    end
-
-    def delete(key)
-      value = self[key]
-      @cache.remove('_id' => key) if value
-      value
-    end
-
-    def store(key, value, options = {})
-      exp = options[:expires_in] ? (Time.now + options[:expires_in]) : nil
-      @cache.update({ '_id' => key }, { '_id' => key, 'data' => value, 'expires' => exp })
-    end
-
-    def update_key(key, options = {})
-      val = self[key]
-      self.store(key, val, options)
-    end
-
-    def clear
-      @cache.clear
-    end
-  end
-end
-

data/lib/moneta/redis.rb

@@ -1,49 +0,0 @@
-begin
-  require "redis"
-rescue LoadError
-  puts "You need the redis gem to use the Redis store"
-  exit
-end
-
-module Moneta
-  class Redis
-    include Defaults
-    
-    def initialize(options = {})
-      @cache = ::Redis.new(options)
-    end
-    
-    def key?(key)
-      !@cache[key].nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      @cache.get(key)
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-        
-    def delete(key)
-      value = @cache[key]
-      @cache.delete(key) if value
-      value
-    end
-    
-    def store(key, value, options = {})
-      @cache.set(key, value, options[:expires_in])
-    end
-    
-    def update_key(key, options = {})
-      val = @cache[key]
-      self.store(key, val, options)
-    end
-    
-    def clear
-      @cache.flush_db
-    end
-  end
-end

data/lib/moneta/rufus.rb

@@ -1,41 +0,0 @@
-begin
-  require "rufus/tokyo"
-rescue LoadError
-  puts "You need the rufus gem to use the Rufus moneta store"
-  exit
-end
-
-module Moneta
-  class BasicRufus < ::Rufus::Tokyo::Cabinet 
-    include Defaults
-       
-    def initialize(options = {})
-      file = options[:file]
-      super("#{file}.tch")
-    end
-    
-    def key?(key)
-      !!self[key]
-    end
-    
-    def [](key)
-      if val = super
-        Marshal.load(val.unpack("m")[0])
-      end
-    end
-    
-    def []=(key, value)
-      super(key, [Marshal.dump(value)].pack("m"))
-    end    
-  end
-  
-  class Rufus < BasicRufus
-    include Expires
-    
-    def initialize(options = {})
-      file = options[:file]
-      @expiration = BasicRufus.new(:file => "#{file}_expires")
-      super
-    end
-  end
-end

data/lib/moneta/s3.rb

@@ -1,162 +0,0 @@
-begin
-  require "right_aws"
-rescue LoadError
-  puts "You need the RightScale AWS gem to use the S3 moneta store"
-  exit  
-end
-
-module Moneta
-  # An S3 implementation of Moneta
-  #
-  # Example usage:
-  #
-  #   require 'rubygems'
-  #   require 'moneta'
-  #   require 'moneta/s3'
-  #
-  #   store = Moneta::S3.new(
-  #     :access_key_id => 'ACCESS_KEY_ID', 
-  #     :secret_access_key => 'SECRET_ACCESS_KEY', 
-  #     :bucket => 'a_bucket'
-  #   )
-  #   store['somefile'] 
-  class S3
-    # Initialize the Moneta::S3 store.
-    #
-    # Required values passed in the options hash:
-    # * <tt>:access_key_id</tt>: The access id key
-    # * <tt>:secret_access_key</tt>: The secret key
-    # * <tt>:bucket</tt>: The name of bucket. Will be created if it doesn't
-    # exist.
-    # * <tt>:multi_thread</tt>: Set to true if using threading
-    def initialize(options = {})
-      validate_options(options)
-      s3 = RightAws::S3.new(
-        options[:access_key_id], 
-        options[:secret_access_key], 
-        {
-          :logger => logger, 
-          :multi_thread => options.delete(:multi_thread) || false
-        }
-      )
-      @bucket = s3.bucket(options.delete(:bucket), true)
-    end
-    
-    def key?(key)
-      !s3_key(key).nil?
-    end
-    
-    alias has_key? key?
-    
-    def [](key)
-      get(key)
-    end
-    
-    def []=(key, value)
-      store(key, value)
-    end
-        
-    def delete(key)
-      k = s3_key(key)
-      if k
-        value = k.get
-        k.delete
-        value
-      end
-    end
-    
-    # Store the key/value pair.
-    # 
-    # Options:
-    # *<tt>:meta_headers</tt>: Meta headers passed to S3
-    # *<tt>:perms</tt>: Permissions passed to S3
-    # *<tt>:headers</tt>: Headers sent as part of the PUT request
-    # *<tt>:expires_in</tt>: Number of seconds until expiration
-    def store(key, value, options = {})
-      debug "store(key=#{key}, value=#{value}, options=#{options.inspect})"
-      meta_headers = meta_headers_from_options(options)
-      perms = options[:perms]
-      headers = options[:headers] || {}
-      
-      case value
-      when IO
-        @bucket.put(key, value.read, meta_headers, perms, headers)
-      else
-        @bucket.put(key, value, meta_headers, perms, headers)
-      end
-    end
-    
-    def update_key(key, options = {})
-      debug "update_key(key=#{key}, options=#{options.inspect})"
-      k = s3_key(key, false)
-      k.save_meta(meta_headers_from_options(options)) unless k.nil?
-    end
-    
-    def clear
-      @bucket.clear
-    end
-    
-    protected
-    def logger
-      @logger ||= begin
-        logger = Logger.new(STDOUT)
-        logger.level = Logger::FATAL
-        logger
-      end
-    end
-    
-    private
-    def validate_options(options)
-      unless options[:access_key_id]
-        raise RuntimeError, ":access_key_id is required in options"
-      end
-      unless options[:secret_access_key]
-        raise RuntimeError, ":secret_access_key is required in options"
-      end
-      unless options[:bucket]
-        raise RuntimeError, ":bucket is required in options"
-      end
-    end
-    
-    def get(key)
-      k = s3_key(key)
-      k.nil? ? nil : k.get
-    end
-    
-    def s3_key(key, nil_if_expired=true)
-      begin
-        s3_key = @bucket.key(key, true)
-        if s3_key.exists?
-          logger.debug "[Moneta::S3] key exists: #{key}"
-          if s3_key.meta_headers.has_key?('expires-at')
-            expires_at = Time.parse(s3_key.meta_headers['expires-at'])
-            if Time.now > expires_at && nil_if_expired
-              # TODO delete the object?
-              debug "key expired: #{key} (@#{s3_key.meta_headers['expires-at']})"
-              return nil
-            end
-          end
-          return s3_key
-        else
-          debug "key does not exist: #{key}"
-        end
-      rescue RightAws::AwsError => e
-        debug "key does not exist: #{key}"
-      end
-      nil
-    end
-    
-    def meta_headers_from_options(options={})
-      meta_headers = options[:meta_headers] || {}
-      if options[:expires_in]
-        meta_headers['expires-at'] = (Time.now + options[:expires_in]).rfc2822
-      end
-      debug "setting expires-at: #{meta_headers['expires-at']}"
-      meta_headers
-    end
-    
-    def debug(message)
-      logger.debug "[Moneta::S3] #{message}"
-    end
-  end
-end