dragonfly-fog_data_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a23ec2299440686776fa108cbc70825fa8c68e8a
+  data.tar.gz: 89bc14ed227cf097b8164b4ceebf856ec4f9fcae
+SHA512:
+  metadata.gz: 36dabbedf624890cf291d9645c1a2f3fb2123284a23eda4b7df0174a03a1ce9008d8604b991674db8866864936926f6c8854224180dc154094295a6573125ea8
+  data.tar.gz: cd68c161eb8db2427c039c5bed98bec3479d4cbcbc5b59d1b231f263e2e678514077e77a33d4243356aa2da091a0199928f7587f3cc2bf994fe63fce6503890f

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.fog_spec.yml
+.DS_Store

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jimmy Hsu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+# Dragonfly::FogDataStore
+
+This is shamelessly stolen from https://github.com/markevans/dragonfly-s3_data_store.
+
+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

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

data/dragonfly-fog_data_store.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+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.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.homepage      = "https://github.com/irregularprofit/dragonfly-fog_data_store"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "dragonfly", "~> 1.0"
+  spec.add_runtime_dependency "fog", '~> 0'
+  spec.add_development_dependency "rspec", "~> 2.0"
+end

data/lib/dragonfly/fog_data_store/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  class FogDataStore
+    VERSION = "0.0.1"
+  end
+end

data/lib/dragonfly/fog_data_store.rb

@@ -0,0 +1,115 @@
+require 'fog'
+require 'dragonfly'
+
+Dragonfly::App.register_datastore(:fog){ Dragonfly::FogDataStore }
+
+module Dragonfly
+  class FogDataStore
+
+    # 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]
+
+      @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
+
+    def write(content, opts={})
+      ensure_configured
+      ensure_bucket_initialized
+
+      headers = {'Content-Type' => content.mime_type}
+      headers.merge!(opts[:headers]) if opts[:headers]
+      uid = opts[:path] || generate_uid(content.name || 'file')
+
+      rescuing_socket_errors do
+        content.file do |f|
+          storage.put_object(bucket_name, uid, f, headers)
+        end
+      end
+
+      uid
+    end
+
+    def read(uid)
+      ensure_configured
+      response = rescuing_socket_errors{ storage.get_object(bucket_name, uid) }
+      [response.body, response.headers]
+    rescue Excon::Errors::NotFound => e
+      nil
+    end
+
+    def destroy(uid)
+      rescuing_socket_errors{ storage.delete_object(bucket_name, uid) }
+    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?})
+        storage
+      end
+    end
+
+    def bucket_exists?
+      #rescuing_socket_errors{ storage.get_bucket_location(bucket_name) }
+      true
+    rescue Excon::Errors::NotFound => e
+      false
+    end
+
+    private
+
+    def ensure_configured
+      unless @configured
+        [:bucket_name, :rackspace_api_key, :rackspace_username, :rackspace_region].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
+      end
+    end
+
+    def generate_uid(name)
+      "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+    end
+
+    def rescuing_socket_errors(&block)
+      yield
+    rescue Excon::Errors::SocketError => e
+      storage.reload
+      yield
+    end
+
+  end
+end
+

data/spec/fog_data_store_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'dragonfly/spec/data_store_examples'
+require 'yaml'
+require 'dragonfly/fog_data_store'
+
+describe Dragonfly::FogDataStore do
+
+  # To run these tests, put a file ".fog_spec.yml" in the dragonfly root dir, like this:
+  # key: XXXXXXXXXX
+  # secret: XXXXXXXXXX
+  # enabled: true
+  if File.exist?(file = File.expand_path('../../.fog_spec.yml', __FILE__))
+    config = YAML.load_file(file)
+    KEY = config['key']
+    SECRET = config['secret']
+    enabled = config['enabled']
+  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
+
+  end
+
+  it_should_behave_like 'data_store'
+
+  let (:app) { Dragonfly.app }
+  let (:content) { Dragonfly::Content.new(app, "eggheads") }
+  let (:new_content) { Dragonfly::Content.new(app) }
+
+  describe "registering with a symbol" do
+    it "registers a symbol for configuring" do
+      app.configure do
+        datastore :fog
+      end
+      app.datastore.should be_a(Dragonfly::FogDataStore)
+    end
+  end
+
+  describe "write" 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$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == '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$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'eggheads'
+    end
+
+    it "should allow for setting the path manually" do
+      uid = @data_store.write(content, path: 'hello/there')
+      uid.should == 'hello/there'
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == '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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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
+    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)}"
+      @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
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly-fog_data_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- jimmy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: fog data store for Dragonfly
+email:
+- irregular.profit@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dragonfly-fog_data_store.gemspec
+- lib/dragonfly/fog_data_store.rb
+- lib/dragonfly/fog_data_store/version.rb
+- spec/fog_data_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/irregularprofit/dragonfly-fog_data_store
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Data store for storing Dragonfly content (e.g. images) on fog
+test_files:
+- spec/fog_data_store_spec.rb
+- spec/spec_helper.rb