dragonfly-fog_data_store 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ecde557abb73476a4f9fdeca96dddf3ff674e28
-  data.tar.gz: b77a20a8b7ec1c7fdd5cd7c863f274962fc68755
+  metadata.gz: 89d9745c0df7a506740f738e49d72069aadab2ca
+  data.tar.gz: 9fa161c005f635fa3b65e5072a96a87ee6cf0f3d
 SHA512:
-  metadata.gz: 8c4d6662d03df0e686e036fea8e473cf04c7878f2a5b00fe2ef58eeda61b3208211b0edd5bf0fe95ac38372e737415ace9ef175b6a88edd12f9478175999ba33
-  data.tar.gz: 1c8198aca12706c3795e197352a27b3717f1040e2a492b63ca73b0c887f03b1e13184fcba0846e14a6b2deb352f68ccd1d794ba37e39111b022d9a95f2fba84e
+  metadata.gz: c2753d6f7a7d578aa1c8415c2ca934f86d9f75645b19b6b8857b51deb0363d497e22557daaa3489da58296869c24c5b925c84d39e41e964123f7682181e3eff8
+  data.tar.gz: ad9d802aff75030fd9deecfcdf94efb4213433b22cd541896a76e3f9681a4f4ad39befe2ef31d1afc42f7cb136e942ac63bb44c1e4450de91b3e252a7e0ab0bc

data/.gitignore

@@ -15,5 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.fog_spec.yml
-.DS_Store
+.s3_spec.yml
+

data/Gemfile

@@ -1,2 +1,2 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Jimmy Hsu
+Copyright (c) 2015 Jimmy Hsu
 
 MIT License
 

data/README.md

@@ -1,7 +1,49 @@
 # Dragonfly::FogDataStore
 
-This is shamelessly stolen from https://github.com/markevans/dragonfly-s3_data_store.
+  This is shamelessly stolen from
+  https://github.com/markevans/dragonfly-s3_data_store.
+
+## Gemfile
+
+  ```ruby
+gem 'dragonfly-fog_data_store'
+  ```
+
+## Usage
+
+  Configuration (remember the require)
+
+  ```ruby
+require 'dragonfly/fog_data_store'
+
+Dragonfly.app.configure do
+# ...
+
+datastore :fog,
+  container: 'my-container',
+  username: 'blahblahblah',
+  api_key: 'blublublublu',
+  region: 'ord'
+
+# ...
+end
+  ```
+
+### Available configuration options
+
+  ```ruby
+:container
+:username
+:api_key
+:region            # See http://www.rackspace.com/knowledge_center/article/about-regions for options
+:storage_headers   # defaults to {}, can be overridden per-write - see below
+  ```
+
+### Serving directly from S3
+
+  You can get the S3 url using
+
+  ```ruby
+my_model.attachment.url
+  ```
 
-There are failures in the specs arround mocking access to rackspace cloud
-storage.
-As such it's not meant for general consumption yet.

data/Rakefile

@@ -1,2 +1 @@
 require "bundler/gem_tasks"
-require 'bundler'

data/dragonfly-fog_data_store.gemspec

@@ -6,10 +6,10 @@ require 'dragonfly/fog_data_store/version'
 Gem::Specification.new do |spec|
   spec.name          = "dragonfly-fog_data_store"
   spec.version       = Dragonfly::FogDataStore::VERSION
-  spec.authors       = ["jimmy"]
+  spec.authors       = ["Jimmy Hsu"]
   spec.email         = ["irregular.profit@gmail.com"]
-  spec.description   = %q{fog data store for Dragonfly}
-  spec.summary       = %q{Data store for storing Dragonfly content (e.g. images) on fog}
+  spec.description   = %q{Racksapce data store for Dragonfly}
+  spec.summary       = %q{Data store for storing Dragonfly content Rackspace through Fog}
   spec.homepage      = "https://github.com/irregularprofit/dragonfly-fog_data_store"
   spec.license       = "MIT"
 
@@ -19,6 +19,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "dragonfly", "~> 1.0"
-  spec.add_runtime_dependency "fog", '~> 1.28.0'
-  spec.add_development_dependency "rspec", "~> 2.0"
+  spec.add_runtime_dependency "fog", "~> 1.28.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
 end

data/lib/dragonfly/fog_data_store.rb

@@ -9,21 +9,25 @@ module Dragonfly
     # Exceptions
     class NotConfigured < RuntimeError; end
 
-    def initialize(opts={})
-      @bucket_name        = opts[:bucket_name]
-      @rackspace_region   = opts[:rackspace_region]
-      @rackspace_api_key  = opts[:rackspace_api_key]
-      @rackspace_username = opts[:rackspace_username]
+    REGIONS = [:dfw, :ord, :iad, :lon, :syd, :hkg]
 
-      @url_scheme         = opts[:url_scheme] || 'http'
-      @url_host           = opts[:url_host]
+    def initialize(opts={})
+      @container = opts[:container]
+      @username = opts[:username]
+      @api_key = opts[:api_key]
+      @region = opts[:region]
+      @storage_headers = opts[:storage_headers] || {}
+
+      @url_scheme = opts[:url_scheme] || 'http'
+      @url_host = opts[:url_host]
     end
 
-    attr_accessor :bucket_name, :rackspace_api_key, :rackspace_username, :url_scheme, :url_host, :rackspace_region
+    attr_accessor :container, :username, :api_key, :region,
+      :url_scheme, :url_host, :storage_headers
 
     def write(content, opts={})
       ensure_configured
-      ensure_bucket_initialized
+      ensure_container_initialized
 
       headers = {'Content-Type' => content.mime_type}
       headers.merge!(opts[:headers]) if opts[:headers]
@@ -31,7 +35,7 @@ module Dragonfly
 
       rescuing_socket_errors do
         content.file do |f|
-          storage.put_object(bucket_name, uid, f, headers)
+          storage.put_object(container, full_path(uid), f, full_storage_headers(headers, content.meta))
         end
       end
 
@@ -40,43 +44,40 @@ module Dragonfly
 
     def read(uid)
       ensure_configured
-      response = rescuing_socket_errors{ storage.get_object(bucket_name, uid) }
-      [response.body, response.headers]
+
+      response = rescuing_socket_errors{ storage.get_object(container, full_path(uid)) }
+      [response.body, headers_to_meta(response.headers)]
+    rescue Fog::Storage::Rackspace::NotFound
+      nil
     rescue Excon::Errors::NotFound => e
       nil
     end
 
     def destroy(uid)
-      rescuing_socket_errors{ storage.delete_object(bucket_name, uid) }
+      rescuing_socket_errors{ storage.delete_object(container, full_path(uid)) }
+    rescue Fog::Storage::Rackspace::NotFound
+      nil
     rescue Excon::Errors::NotFound, Excon::Errors::Conflict => e
       Dragonfly.warn("#{self.class.name} destroy error: #{e}")
     end
 
-    def url_for(uid, opts={})
-      if opts && opts[:expires]
-        storage.get_object_https_url(bucket_name, uid, opts[:expires])
-      else
-        scheme = opts[:scheme] || url_scheme
-        host   = opts[:host]   || url_host
-        "#{scheme}://#{host}/#{uid}"
-      end
-    end
-
     def storage
       @storage ||= begin
         storage = Fog::Storage.new({
           provider: 'Rackspace',
-          rackspace_region: rackspace_region,
-          rackspace_api_key: rackspace_api_key,
-          rackspace_username: rackspace_username
-        }.reject {|name, option| option.nil?})
+          rackspace_username: username,
+          rackspace_api_key: api_key,
+          rackspace_region: region
+        })
         storage
       end
     end
 
-    def bucket_exists?
-      #rescuing_socket_errors{ storage.get_bucket_location(bucket_name) }
+    def container_exists?
+      rescuing_socket_errors{ storage.get_container(container) }
       true
+    rescue Fog::Storage::Rackspace::NotFound
+      nil
     rescue Excon::Errors::NotFound => e
       false
     end
@@ -85,24 +86,49 @@ module Dragonfly
 
     def ensure_configured
       unless @configured
-        [:bucket_name, :rackspace_api_key, :rackspace_username, :rackspace_region].each do |attr|
+        [:container, :username, :api_key, :container].each do |attr|
           raise NotConfigured, "You need to configure #{self.class.name} with #{attr}" if send(attr).nil?
         end
         @configured = true
       end
     end
 
-    def ensure_bucket_initialized
-      unless @bucket_initialized
-        rescuing_socket_errors{ storage.put_bucket(bucket_name, 'LocationConstraint' => rackspace_region) } unless bucket_exists?
-        @bucket_initialized = true
+    def ensure_container_initialized
+      unless @container_initialized
+        rescuing_socket_errors{ storage.put_container(container) } unless container_exists?
+        @container_initialized = true
       end
     end
 
+    def get_region
+      reg = region || :ord
+      raise "Invalid region #{reg} - should be one of #{REGIONS.join(', ')}" unless REGIONS.include?(reg)
+      reg
+    end
+
     def generate_uid(name)
       "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
     end
 
+    def full_path(uid)
+      File.join *[uid].compact
+    end
+
+    def full_storage_headers(headers, meta)
+      storage_headers.merge(meta_to_headers(meta)).merge(headers)
+    end
+
+    def headers_to_meta(headers)
+      json = headers['X-Object-Meta']
+      if json && !json.empty?
+        Serializer.json_decode(json)
+      end
+    end
+
+    def meta_to_headers(meta)
+      {'X-Object-Meta' => Serializer.json_encode(meta)}
+    end
+
     def rescuing_socket_errors(&block)
       yield
     rescue Excon::Errors::SocketError => e
@@ -112,4 +138,3 @@ module Dragonfly
 
   end
 end
-

data/lib/dragonfly/fog_data_store/version.rb

@@ -1,5 +1,5 @@
 module Dragonfly
   class FogDataStore
-    VERSION = "0.0.2"
+    VERSION = "0.0.4"
   end
 end

data/spec/fog_data_store_spec.rb

@@ -17,39 +17,18 @@ describe Dragonfly::FogDataStore do
   else
     enabled = false
   end
-
-  if enabled
-
-    # Make sure it's a new bucket name
-    BUCKET_NAME = "dragonfly-test-#{Time.now.to_i.to_s(36)}"
-    REGION = :ord
-
-    before(:each) do
-      @data_store = Dragonfly::FogDataStore.new(
-        bucket_name: BUCKET_NAME,
-        provider: 'Rackspace',
-        rackspace_api_key: KEY,
-        rackspace_username: SECRET,
-        rackspace_region: REGION
-      )
-    end
-
-  else
-
-    BUCKET_NAME = 'test-bucket'
-    REGION = :ord
-
-    before(:each) do
-      Fog.mock!
-      @data_store = Dragonfly::FogDataStore.new(
-        bucket_name: BUCKET_NAME,
-        provider: 'Rackspace',
-        rackspace_api_key: 'XXXXXXXXX',
-        rackspace_username: 'XXXXXXXXX',
-        rackspace_region: REGION
-      )
-    end
-
+  CONTAINER = 'test-container'
+
+  before(:each) do
+    Fog.mock!
+    @data_store = Dragonfly::FogDataStore.new(
+      provider: 'Rackspace',
+      username: 'XXXXXXXXX',
+      api_key: 'XXXXXXXXX',
+      region: 'ord',
+      secret: 'super-secret-key-no-one-can-guess',
+      container: CONTAINER
+    )
   end
 
   it_should_behave_like 'data_store'
@@ -63,7 +42,7 @@ describe Dragonfly::FogDataStore do
       app.configure do
         datastore :fog
       end
-      app.datastore.should be_a(Dragonfly::FogDataStore)
+      expect(app.datastore).to be_a(Dragonfly::FogDataStore)
     end
   end
 
@@ -71,97 +50,121 @@ describe Dragonfly::FogDataStore do
     it "should use the name from the content if set" do
       content.name = 'doobie.doo'
       uid = @data_store.write(content)
-      uid.should =~ /doobie\.doo$/
+      expect(uid).to match(/doobie\.doo$/)
       new_content.update(*@data_store.read(uid))
-      new_content.data.should == 'eggheads'
+      expect(new_content.data).to eq('eggheads')
     end
 
     it "should work ok with files with funny names" do
       content.name = "A Picture with many spaces in its name (at 20:00 pm).png"
       uid = @data_store.write(content)
-      uid.should =~ /A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/
+      expect(uid).to match(/A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/)
       new_content.update(*@data_store.read(uid))
-      new_content.data.should == 'eggheads'
+      expect(new_content.data).to eq('eggheads')
     end
 
     it "should allow for setting the path manually" do
       uid = @data_store.write(content, path: 'hello/there')
-      uid.should == 'hello/there'
+      expect(uid).to eq('hello/there')
       new_content.update(*@data_store.read(uid))
-      new_content.data.should == 'eggheads'
+      expect(new_content.data).to eq('eggheads')
     end
 
-    if enabled # Fog.mock! doesn't act consistently here
-      it "should reset the connection and try again if Fog throws a socket EOFError" do
-        @data_store.storage.should_receive(:put_object).exactly(:once).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        @data_store.storage.should_receive(:put_object).with(BUCKET_NAME, anything, anything, hash_including)
-        @data_store.write(content)
-      end
-
-      it "should just let it raise if Fog throws a socket EOFError again" do
-        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        @data_store.storage.should_receive(:put_object).and_raise(Excon::Errors::SocketError.new(EOFError.new))
-        expect{
-          @data_store.write(content)
-        }.to raise_error(Excon::Errors::SocketError)
-      end
-    end
   end
 
   describe "not configuring stuff properly" do
-    it "should require a bucket name on write" do
-      @data_store.bucket_name = nil
-      proc{ @data_store.write(content) }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+    it "should require a container name on write" do
+      @data_store.container = nil
+      expect{ @data_store.write(content) }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
 
-    it "should require an rackspace_api_key on write" do
-      @data_store.rackspace_api_key = nil
-      proc{ @data_store.write(content) }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+    it "should require an username on write" do
+      @data_store.username = nil
+      expect{ @data_store.write(content) }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
 
     it "should require a secret access key on write" do
-      @data_store.rackspace_username = nil
-      proc{ @data_store.write(content) }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+      @data_store.api_key = nil
+      expect{ @data_store.write(content) }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
 
-    it "should require a bucket name on read" do
-      @data_store.bucket_name = nil
-      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+    it "should require a container name on read" do
+      @data_store.container = nil
+      expect{ @data_store.read('asdf') }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
 
-    it "should require an rackspace_api_key on read" do
-      @data_store.rackspace_api_key = nil
-      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+    it "should require an username on read" do
+      @data_store.username = nil
+      expect{ @data_store.read('asdf') }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
 
     it "should require a secret access key on read" do
-      @data_store.rackspace_username = nil
-      proc{ @data_store.read('asdf') }.should raise_error(Dragonfly::FogDataStore::NotConfigured)
+      @data_store.api_key = nil
+      expect{ @data_store.read('asdf') }.to raise_error(Dragonfly::FogDataStore::NotConfigured)
     end
+  end
 
-    if !enabled #this will fail since the specs are not running on an ec2 instance with an iam role defined
-      it 'should allow missing secret key and access key on write if iam profiles are allowed' do
-        # This is slightly brittle but it's annoying waiting for fog doing stuff
-        @data_store.storage.stub(get_bucket_location: nil, put_object: nil)
-
-        @data_store.rackspace_username = nil
-        @data_store.rackspace_api_key = nil
-        expect{ @data_store.write(content) }.not_to raise_error
-      end
+  describe "autocreating the container" do
+    it "should create the container on write if it doesn't exist" do
+      @data_store.container = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      @data_store.write(content)
     end
 
+    it "should not try to create the container on read if it doesn't exist" do
+      @data_store.container = "dragonfly-test-blah-blah-#{rand(100000000)}"
+      expect(@data_store.send(:storage)).to_not receive(:put_container)
+      expect(@data_store.read("gungle")).to be_nil
+    end
   end
 
-  describe "autocreating the bucket" do
-    it "should create the bucket on write if it doesn't exist" do
-      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
+  describe "headers" do
+    before(:each) do
+      @data_store.storage_headers = {'x-fog-foo' => 'biscuithead'}
+    end
+
+    it "should allow configuring globally" do
+      expect(@data_store.storage).to receive(:put_object).with(CONTAINER, anything, anything,
+                                                           hash_including('x-fog-foo' => 'biscuithead')
+                                                          )
+      @data_store.write(content)
+    end
+
+    it "should allow adding per-store" do
+      expect(@data_store.storage).to receive(:put_object).with(CONTAINER, anything, anything,
+                                                           hash_including('x-fog-foo' => 'biscuithead', 'hello' => 'there')
+                                                          )
+      @data_store.write(content, headers: {'hello' => 'there'})
+    end
+
+    it "should let the per-store one take precedence" do
+      expect(@data_store.storage).to receive(:put_object).with(CONTAINER, anything, anything,
+                                                           hash_including('x-fog-foo' => 'override!')
+                                                          )
+      @data_store.write(content, headers: {'x-fog-foo' => 'override!'})
+    end
+
+    it "should write setting the content type" do
+      expect(@data_store.storage).to receive(:put_object) do |_, __, ___, headers|
+        expect(headers['Content-Type']).to eq('image/png')
+      end
+      content.name = 'egg.png'
       @data_store.write(content)
     end
 
-    it "should not try to create the bucket on read if it doesn't exist" do
-      @data_store.bucket_name = "dragonfly-test-blah-blah-#{rand(100000000)}"
-      @data_store.send(:storage).should_not_receive(:put_bucket)
-      @data_store.read("gungle").should be_nil
+    it "allow overriding the content type" do
+      expect(@data_store.storage).to receive(:put_object) do |_, __, ___, headers|
+        expect(headers['Content-Type']).to eq('text/plain')
+      end
+      content.name = 'egg.png'
+      @data_store.write(content, headers: {'Content-Type' => 'text/plain'})
+    end
+  end
+
+  describe "meta" do
+    it "uses the X-Object-Meta header for meta" do
+      uid = @data_store.write(content, headers: {'X-Object-Meta' => Dragonfly::Serializer.json_encode({potato: 44})})
+      c, meta = @data_store.read(uid)
+      expect(meta['potato']).to eq(44)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dragonfly-fog_data_store
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
-- jimmy
+- Jimmy Hsu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dragonfly
@@ -44,15 +44,15 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-description: fog data store for Dragonfly
+        version: '3.2'
+description: Racksapce data store for Dragonfly
 email:
 - irregular.profit@gmail.com
 executables: []
@@ -92,7 +92,7 @@ rubyforge_project:
 rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
-summary: Data store for storing Dragonfly content (e.g. images) on fog
+summary: Data store for storing Dragonfly content Rackspace through Fog
 test_files:
 - spec/fog_data_store_spec.rb
 - spec/spec_helper.rb