benschwarz-smoke 0.4.2 → 0.5.0

data/vendor/moneta/lib/moneta/s3.rb

@@ -0,0 +1,162 @@
+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

data/vendor/moneta/lib/moneta/sdbm.rb

@@ -0,0 +1,33 @@
+require "sdbm"
+
+module Moneta
+  class BasicSDBM < ::SDBM
+    include Defaults
+
+    def [](key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+
+    def []=(key, value)
+      super(key, Marshal.dump(value))
+    end
+
+    def delete(key)
+      if val = super
+        Marshal.load(val)
+      end
+    end
+  end
+
+  class SDBM < BasicSDBM
+    include Expires
+
+    def initialize(options = {})
+      raise "No :file option specified" unless file = options[:file]
+      @expiration = BasicSDBM.new("#{file}_expires")
+      super(file)
+    end
+  end
+end

data/vendor/moneta/lib/moneta/tyrant.rb

@@ -0,0 +1,58 @@
+begin
+  require "rufus/tokyo/tyrant"
+rescue LoadError
+  puts "You need the rufus gem to use the Tyrant moneta store"
+  exit
+end
+
+module Moneta
+  class Tyrant < ::Rufus::Tokyo::Tyrant
+    include Defaults
+    
+    module Implementation
+      def initialize(options = {})
+        host = options[:host]
+        port = options[:port]
+        super(host, port)
+      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
+    
+    include Implementation
+    include Expires
+    
+    def initialize(options = {})
+      super
+      @expiration = Expiration.new(options)
+    end
+    
+    class Expiration < ::Rufus::Tokyo::Tyrant
+      include Implementation
+      
+      def [](key)
+        super("#{key}__expiration")
+      end
+      
+      def []=(key, value)
+        super("#{key}__expiration", value)
+      end
+      
+      def delete(key)
+        super("#{key}__expiration")
+      end
+    end
+  end  
+end

data/vendor/moneta/lib/moneta/xattr.rb

@@ -0,0 +1,58 @@
+begin
+  require "xattr"
+rescue LoadError
+  puts "You need the xattr gem to use the Xattr moneta store"
+  exit
+end
+require "fileutils"
+
+module Moneta
+  class Xattr
+    include Defaults
+    
+    def initialize(options = {})
+      file = options[:file]
+      @hash = ::Xattr.new(file)
+      FileUtils.mkdir_p(::File.dirname(file))
+      FileUtils.touch(file)
+      unless options[:skip_expires]
+        @expiration = Moneta::Xattr.new(:file => "#{file}_expiration", :skip_expires => true)
+        self.extend(Expires)
+      end
+    end
+    
+    module Implementation
+      
+      def key?(key)
+        @hash.list.include?(key)
+      end
+      
+      alias has_key? key?
+      
+      def [](key)
+        return nil unless key?(key)
+        Marshal.load(@hash.get(key))
+      end
+      
+      def []=(key, value)
+        @hash.set(key, Marshal.dump(value))
+      end
+      
+      def delete(key)
+        return nil unless key?(key)
+        value = self[key]
+        @hash.remove(key)
+        value
+      end
+      
+      def clear
+        @hash.list.each do |item|
+          @hash.remove(item)
+        end
+      end
+      
+    end
+    include Implementation
+    
+  end
+end

data/vendor/moneta/lib/moneta.rb

@@ -0,0 +1,76 @@
+module Moneta
+  module Expires
+    def check_expired(key)
+      if @expiration[key] && Time.now > @expiration[key]
+        @expiration.delete(key)
+        self.delete(key)
+      end
+    end
+
+    def key?(key)
+      check_expired(key)
+      super
+    end
+
+    def [](key)
+      check_expired(key)
+      super
+    end
+
+    def fetch(key, default = nil, &blk)
+      check_expired(key)
+      super
+    end
+
+    def delete(key)
+      check_expired(key)
+      super
+    end
+
+    def update_key(key, options)
+      update_options(key, options)
+    end
+
+    def store(key, value, options = {})
+      ret = super(key, value)
+      update_options(key, options)
+      ret
+    end
+
+    private
+    def update_options(key, options)
+      if options[:expires_in]
+        @expiration[key] = (Time.now + options[:expires_in])
+      end
+    end
+  end
+
+  module StringExpires
+    include Expires
+
+    def check_expired(key)
+      if @expiration[key] && Time.now > Time.at(@expiration[key].to_i)
+        @expiration.delete(key)
+        delete(key)
+      end
+    end
+
+    private
+    def update_options(key, options)
+      if options[:expires_in]
+        @expiration[key] = (Time.now + options[:expires_in]).to_i.to_s
+      end
+    end
+  end
+  
+  module Defaults
+    def fetch(key, value = nil)
+      value ||= block_given? ? yield(key) : default
+      self[key] || value
+    end
+    
+    def store(key, value, options = {})
+      self[key] = value
+    end        
+  end
+end

data/vendor/moneta/moneta.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+# June 1, 1:00pm
+
+Gem::Specification.new do |s|
+  s.name = %q{moneta}
+  s.version = "0.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Yehuda Katz"]
+  s.autorequire = %q{moneta}
+  s.date = %q{2009-02-12}
+  s.description = %q{A unified interface to key/value stores}
+  s.email = %q{wycats@gmail.com}
+  s.extra_rdoc_files = ["README", "LICENSE", "TODO"]
+  s.files = ["LICENSE", "README", "Rakefile", "TODO", "lib/moneta", "lib/moneta/datamapper.rb", "lib/moneta/file.rb", "lib/moneta/memcache.rb", "lib/moneta/memory.rb", "lib/moneta/xattr.rb", "lib/moneta.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://www.yehudakatz.com}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A unified interface to key/value stores}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/vendor/moneta/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/vendor/moneta/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:newgem_simple, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/vendor/moneta/spec/moneta_basic_file_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require "moneta/basic_file"
+
+  describe "Moneta::BasicFile" do
+    describe "without namespacing" do
+      before(:each) do
+        @cache = Moneta::BasicFile.new(:path => File.join(File.dirname(__FILE__), "basic_file_cache"))
+        @cache.clear
+      end
+      
+      if ENV['MONETA_TEST'].nil? || ENV['MONETA_TEST'] == 'basic_file'
+        it_should_behave_like "a read/write Moneta cache"
+      end
+      
+      it "should deal with '/' and '#' in a key" do
+        key = "hello/mom#crazycharacters"
+        @cache[key] = "hi"
+        @cache[key].should == "hi"
+        ::File.exists?(File.join(File.dirname(__FILE__), "basic_file_cache", "")).should == true
+      end
+    end
+    
+    describe "with namespacing" do
+      before(:each) do
+        @cache = Moneta::BasicFile.new(:path => File.join(File.dirname(__FILE__), "basic_file_cache"), :namespace => "test_namespace")
+        @cache.clear
+      end
+      
+      if ENV['MONETA_TEST'].nil? || ENV['MONETA_TEST'] == 'basic_file'
+        it_should_behave_like "a read/write Moneta cache"
+      end
+      
+      it "should act as two stores within the same directory" do
+        @second = Moneta::BasicFile.new(:path => File.join(File.dirname(__FILE__), "basic_file_cache"), :namespace => "second_namespace")
+        @second[:key] = "hello"
+        @cache[:key] = "world!"
+        @second[:key].should == "hello"
+        @cache[:key].should == "world!"
+      end
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(File.join(File.dirname(__FILE__), "basic_file_cache"))
+    end
+    
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_berkeley_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require 'moneta/berkeley'
+
+  describe "Moneta::Berkeley" do
+    before(:each) do
+      @cache = Moneta::Berkeley.new(:file => File.join(File.dirname(__FILE__), "berkeley_test.db"))
+      @cache.clear
+    end
+  
+    after(:all) do
+      File.delete(File.join(File.dirname(__FILE__), "berkeley_test.db"))
+      File.delete(File.join(File.dirname(__FILE__), "berkeley_test.db_expiration"))
+    end
+  
+    it_should_behave_like "a read/write Moneta cache"
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_couch_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require 'moneta/couch'
+
+  describe "Moneta::Couch" do
+    before(:each) do
+      @cache = Moneta::Couch.new(:db => "couch_test")
+      @expiration = Moneta::Couch.new(:db => "couch_test_expiration", :skip_expires => true)
+      @cache.clear
+      @expiration.clear
+    end
+
+    after(:all) do
+      @cache.delete_store
+      @expiration.delete_store
+    end
+
+    it_should_behave_like "a read/write Moneta cache"
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_datamapper_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require "moneta/datamapper"
+  
+  describe "Moneta::DataMapper" do
+
+    describe "default repository" do
+      before(:each) do
+        @cache = Moneta::DataMapper.new(:setup => "sqlite3::memory:")
+        @cache.clear
+      end
+  
+      after(:all) do
+        repository(:moneta) { MonetaHash.auto_migrate! }
+      end
+
+      it_should_behave_like "a read/write Moneta cache"
+    end
+
+    describe "when :repository specified" do
+      before(:each) do
+        @cache = Moneta::DataMapper.new(:repository => :sample, :setup => "sqlite3::memory:")
+        @cache.clear
+      end
+
+      after(:all) do
+        repository(:sample) { MonetaHash.auto_migrate! }
+      end
+
+      it_should_behave_like "a read/write Moneta cache"
+    end
+
+    describe "with multple stores" do
+      before(:each) do
+        @default_cache = Moneta::DataMapper.new(:setup => "sqlite3:moneta.db")
+        @default_cache.clear
+
+        @sample_cache = Moneta::DataMapper.new(:repository => :sample, :setup => "sqlite3:sample.db")
+        @sample_cache.clear
+      end
+
+      after(:all) do
+        File.delete('moneta.db')
+        File.delete('sample.db')
+      end
+
+      # TODO should there be more tests than these?
+      it "does not cross contaminate when storing" do
+        @default_cache["key"] = "value"
+        @sample_cache["key"] = "value2"
+
+        @default_cache["key"].should == "value"
+        @sample_cache["key"].should == "value2"
+      end
+
+      it "does not cross contaminate when deleting" do
+        @default_cache["key"] = "value"
+        @sample_cache["key"] = "value2"
+
+        @default_cache.delete("key").should == "value"
+        @default_cache.key?("key").should be_false
+        @sample_cache["key"].should == "value2"
+      end
+
+      it "does not cross contaminate when expiring" do
+        @default_cache.store("key", "value", :expires_in => 2)
+        @sample_cache["key"] = "value2"
+
+        time = Time.now
+        Time.stub!(:now).and_return { time + 2 }
+
+        @default_cache["key"].should == nil
+        @sample_cache["key"].should == "value2"
+      end
+    end
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_file_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require "moneta/file"
+
+  describe "Moneta::File" do
+    before(:each) do
+      @cache = Moneta::File.new(:path => File.join(File.dirname(__FILE__), "file_cache"))
+      @cache.clear
+    end
+
+    after(:all) do
+      FileUtils.rm_rf(File.join(File.dirname(__FILE__), "file_cache"))
+    end
+
+    if ENV['MONETA_TEST'].nil? || ENV['MONETA_TEST'] == 'file'
+      it_should_behave_like "a read/write Moneta cache"
+    end
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_lmc_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require "moneta/lmc"
+  require "fileutils"
+
+  # Problem: If there are multiple caches around, they start
+  # to block (with a system semaphore), which can be unpleasant
+  # so just use one cache for the entire test run.
+  $lmc_cache = Moneta::LMC.new(:filename => "test")
+
+  describe "Moneta::LMC" do
+    before(:all) do
+      @cache = $lmc_cache
+    end
+    
+    after(:each) do
+      @cache.clear
+    end
+    
+    it_should_behave_like "a read/write Moneta cache"
+  end
+rescue SystemExit
+end

data/vendor/moneta/spec/moneta_memcache_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+begin
+  require "moneta/memcache"
+
+  describe "Moneta::Memcache" do
+    before(:each) do
+      @native_expires = true
+      @cache = Moneta::Memcache.new(:server => "localhost:11211", :namespace => "moneta_spec")
+      @cache.clear
+    end
+  
+    it_should_behave_like "a read/write Moneta cache"
+  end
+rescue SystemExit
+end