oahu-dragonfly 0.8.2

data/lib/dragonfly/core_ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+
+  def to_dragonfly_unique_s
+    map{|item| item.to_dragonfly_unique_s }.join
+  end
+
+end

data/lib/dragonfly/core_ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+
+  def to_dragonfly_unique_s
+    sort_by{|k, v| k.to_dragonfly_unique_s }.to_dragonfly_unique_s
+  end
+
+end

data/lib/dragonfly/core_ext/object.rb

@@ -0,0 +1,12 @@
+class Object
+  
+  # Don't want to depend on activesupport for this
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def to_dragonfly_unique_s
+    to_s
+  end
+  
+end

data/lib/dragonfly/core_ext/string.rb

@@ -0,0 +1,9 @@
+class String
+  
+  # Ruby 1.8 reports methods as strings,
+  # whereas 1.9 reports them as symbols
+  def to_method_name
+    RUBY_VERSION =~ /^1.8/ ? self : to_sym
+  end
+
+end

data/lib/dragonfly/core_ext/symbol.rb

@@ -0,0 +1,9 @@
+class Symbol
+  
+  # Ruby 1.8 reports methods as strings,
+  # whereas 1.9 reports them as symbols
+  def to_method_name
+    RUBY_VERSION =~ /^1.8/ ? to_s : self
+  end
+  
+end

data/lib/dragonfly/data_storage.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  module DataStorage
+
+    # Exceptions
+    class DataNotFound < StandardError; end
+    class UnableToStore < StandardError; end
+
+  end
+end

data/lib/dragonfly/data_storage/couch_data_store.rb

@@ -0,0 +1,64 @@
+require 'couchrest'
+
+module Dragonfly
+  module DataStorage
+    class CouchDataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :host, 'localhost'
+      configurable_attr :port, '5984'
+      configurable_attr :database, 'dragonfly'
+      configurable_attr :username
+      configurable_attr :password
+
+      def initialize(opts={})
+        self.host = opts[:host]
+        self.port = opts[:port]
+        self.database = opts[:database] if opts[:database]
+        self.username = opts[:username]
+        self.password = opts[:password]
+      end
+
+      def store(temp_object, opts={})
+        meta = opts[:meta] || {}
+        name = meta[:name] || temp_object.original_filename || 'file'
+        content_type = opts[:content_type] || opts[:mime_type] || 'application/octet-stream'
+        
+        temp_object.file do |f|
+          doc = CouchRest::Document.new(:meta => marshal_encode(meta))
+          response = db.save_doc(doc)
+          doc.put_attachment(name, f, {:content_type => content_type})
+          response['id']
+        end
+      rescue RuntimeError => e
+        raise UnableToStore, "#{e} - #{temp_object.inspect}"
+      end
+
+      def retrieve(uid)
+        doc = db.get(uid)
+        name = doc['_attachments'].keys.first
+        [doc.fetch_attachment(name), marshal_decode(doc['meta'])]
+      rescue RestClient::ResourceNotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        doc = db.get(uid)
+        db.delete_doc(doc)
+      rescue RestClient::ResourceNotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def db
+        @db ||= begin
+          auth = username.blank? ? nil : "#{username}:#{password}@"
+          url = "http://#{auth}#{host}:#{port}"
+          CouchRest.new(url).database!(database)
+        end
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -0,0 +1,141 @@
+require 'pathname'
+
+module Dragonfly
+  module DataStorage
+
+    class FileDataStore
+
+      # Exceptions
+      class UnableToFormUrl < RuntimeError; end
+
+      include Configurable
+
+      configurable_attr :root_path, '/var/tmp/dragonfly'
+      configurable_attr :server_root
+      configurable_attr :store_meta, true
+
+      def store(temp_object, opts={})
+        meta = opts[:meta] || {}
+        relative_path = if opts[:path]
+          opts[:path]
+        else
+          filename = meta[:name] || temp_object.original_filename || 'file'
+          relative_path = relative_path_for(filename)
+        end
+
+        begin
+          path = absolute(relative_path)
+          until !File.exist?(path)
+            path = disambiguate(path)
+          end
+          prepare_path(path)
+          temp_object.to_file(path).close
+          store_meta_data(path, meta) if store_meta
+        rescue Errno::EACCES => e
+          raise UnableToStore, e.message
+        end
+
+        relative(path)
+      end
+
+      def retrieve(relative_path)
+        path = absolute(relative_path)
+        pathname = Pathname.new(path)
+        raise DataNotFound, "couldn't find file #{path}" unless pathname.exist?
+        [
+          pathname,
+          (store_meta ? retrieve_meta_data(path) : {})
+        ]
+      end
+
+      def destroy(relative_path)
+        path = absolute(relative_path)
+        FileUtils.rm path
+        FileUtils.rm_f meta_data_path(path)
+        FileUtils.rm_f deprecated_meta_data_path(path)
+        purge_empty_directories(relative_path)
+      rescue Errno::ENOENT => e
+        raise DataNotFound, e.message
+      end
+
+      def url_for(relative_path, opts={})
+        if server_root.nil?
+          raise NotConfigured, "you need to configure server_root for #{self.class.name} in order to form urls"
+        else
+          _, __, path = absolute(relative_path).partition(server_root)
+          if path.empty?
+            raise UnableToFormUrl, "couldn't form url for uid #{relative_path.inspect} with root_path #{root_path.inspect} and server_root #{server_root.inspect}"
+          else
+            path
+          end
+        end
+      end
+
+      def disambiguate(path)
+        dirname = File.dirname(path)
+        basename = File.basename(path, '.*')
+        extname = File.extname(path)
+        "#{dirname}/#{basename}_#{(Time.now.usec*10 + rand(100)).to_s(32)}#{extname}"
+      end
+
+      private
+
+      def absolute(relative_path)
+        File.join(root_path, relative_path)
+      end
+
+      def relative(absolute_path)
+        absolute_path[/^#{Regexp.escape root_path}\/?(.*)$/, 1]
+      end
+
+      def directory_empty?(path)
+        Dir.entries(path) == ['.','..']
+      end
+
+      def meta_data_path(data_path)
+        "#{data_path}.meta"
+      end
+
+      def deprecated_meta_data_path(data_path)
+        "#{data_path}.extra"
+      end
+
+      def relative_path_for(filename)
+        time = Time.now
+        msec = time.usec / 1000
+        "#{time.strftime '%Y/%m/%d/%H_%M_%S'}_#{msec}_#{filename.gsub(/[^\w.]+/,'_')}"
+      end
+
+      def store_meta_data(data_path, meta)
+        File.open(meta_data_path(data_path), 'wb') do |f|
+          f.write Marshal.dump(meta)
+        end
+      end
+
+      def retrieve_meta_data(data_path)
+        path = meta_data_path(data_path)
+        if File.exist?(path)
+          File.open(path,'rb'){|f| Marshal.load(f.read) }
+        else
+          deprecated_path = deprecated_meta_data_path(data_path)
+          File.exist?(deprecated_path) ? File.open(deprecated_path,'rb'){|f| Marshal.load(f.read) } : {}
+        end
+      end
+
+      def prepare_path(path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.exist?(dir)
+      end
+
+      def purge_empty_directories(path)
+        containing_directory = Pathname.new(path).dirname
+        containing_directory.ascend do |relative_dir|
+          dir = absolute(relative_dir)
+          FileUtils.rmdir dir if directory_empty?(dir)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dragonfly/data_storage/mongo_data_store.rb

@@ -0,0 +1,86 @@
+require 'mongo'
+
+module Dragonfly
+  module DataStorage
+    class MongoDataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :host
+      configurable_attr :port
+      configurable_attr :database, 'dragonfly'
+      configurable_attr :username
+      configurable_attr :password
+      configurable_attr :connection
+      configurable_attr :db
+
+      # Mongo gem deprecated ObjectID in favour of ObjectId
+      OBJECT_ID = defined?(BSON::ObjectId) ? BSON::ObjectId : BSON::ObjectID
+      INVALID_OBJECT_ID = defined?(BSON::InvalidObjectId) ? BSON::InvalidObjectId : BSON::InvalidObjectID
+
+      def initialize(opts={})
+        self.host = opts[:host]
+        self.port = opts[:port]
+        self.database = opts[:database] if opts[:database]
+        self.username = opts[:username]
+        self.password = opts[:password]
+        self.connection = opts[:connection]
+        self.db = opts[:db]
+      end
+
+      def store(temp_object, opts={})
+        ensure_authenticated!
+        temp_object.file do |f|
+          mongo_id = grid.put(f, :metadata => marshal_encode(opts[:meta] || {}))
+          mongo_id.to_s
+        end
+      end
+
+      def retrieve(uid)
+        ensure_authenticated!
+        grid_io = grid.get(bson_id(uid))
+        meta = marshal_decode(grid_io.metadata)
+        meta.merge!(:stored_at => grid_io.upload_date)
+        [
+          grid_io.read,
+          meta
+        ]
+      rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        ensure_authenticated!
+        grid.delete(bson_id(uid))
+      rescue Mongo::GridFileNotFound, INVALID_OBJECT_ID => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def connection
+        @connection ||= Mongo::Connection.new(host, port)
+      end
+
+      def db
+        @db ||= connection.db(database)
+      end
+
+      def grid
+        @grid ||= Mongo::Grid.new(db)
+      end
+
+      private
+
+      def ensure_authenticated!
+        if username
+          @authenticated ||= db.authenticate(username, password)
+        end
+      end
+      
+      def bson_id(uid)
+        OBJECT_ID.from_string(uid)
+      end
+
+    end
+  end
+end

data/lib/dragonfly/data_storage/s3data_store.rb

@@ -0,0 +1,145 @@
+require 'fog'
+
+module Dragonfly
+  module DataStorage
+
+    class S3DataStore
+
+      include Configurable
+      include Serializer
+
+      configurable_attr :bucket_name
+      configurable_attr :access_key_id
+      configurable_attr :secret_access_key
+      configurable_attr :use_filesystem, true
+      configurable_attr :region
+      configurable_attr :storage_headers, {'x-amz-acl' => 'public-read'}
+      configurable_attr :specific_uid
+
+      REGIONS = {
+        'us-east-1'      => 's3.amazonaws.com',  #default
+        'eu-west-1'      => 's3-eu-west-1.amazonaws.com',
+        'ap-southeast-1' => 's3-ap-southeast-1.amazonaws.com',
+        'us-west-1'      => 's3-us-west-1.amazonaws.com'
+      }
+
+      def initialize(opts={})
+        self.bucket_name = opts[:bucket_name]
+        self.access_key_id = opts[:access_key_id]
+        self.secret_access_key = opts[:secret_access_key]
+        self.region = opts[:region]
+      end
+
+      def store(temp_object, opts={})
+        ensure_configured
+        ensure_bucket_initialized
+
+        meta = opts[:meta] || {}
+        headers = opts[:headers] || {}
+        uid = opts[:path] || generate_uid(meta[:name] || temp_object.original_filename || 'file')
+
+        if use_filesystem
+          temp_object.file do |f|
+            storage.put_object(bucket_name, uid, f, full_storage_headers(headers, meta))
+          end
+        else
+          storage.put_object(bucket_name, uid, temp_object.data, full_storage_headers(headers, meta))
+        end
+
+        uid
+      end
+
+      def retrieve(uid)
+        ensure_configured
+        response = storage.get_object(bucket_name, uid)
+        [
+          response.body,
+          parse_s3_metadata(response.headers)
+        ]
+      rescue Excon::Errors::NotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def destroy(uid)
+        storage.delete_object(bucket_name, uid)
+      rescue Excon::Errors::NotFound => e
+        raise DataNotFound, "#{e} - #{uid}"
+      end
+
+      def url_for(uid, opts={})
+        if opts && opts[:expires]
+          storage.get_object_url(bucket_name, uid, opts[:expires])
+        else
+          "http://#{bucket_name}.s3.amazonaws.com/#{uid}"
+        end
+      end
+
+      def domain
+        REGIONS[get_region]
+      end
+
+      def storage
+        @storage ||= Fog::Storage.new(
+          :provider => 'AWS',
+          :aws_access_key_id => access_key_id,
+          :aws_secret_access_key => secret_access_key,
+          :region => region
+        )
+      end
+
+      def bucket_exists?
+        storage.get_bucket_location(bucket_name)
+        true
+      rescue Excon::Errors::NotFound => e
+        false
+      end
+
+      private
+
+      def ensure_configured
+        unless @configured
+          [:bucket_name, :access_key_id, :secret_access_key].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
+          storage.put_bucket(bucket_name, 'LocationConstraint' => region) unless bucket_exists?
+          @bucket_initialized = true
+        end
+      end
+
+      def get_region
+        reg = region || 'us-east-1'
+        raise "Invalid region #{reg} - should be one of #{valid_regions.join(', ')}" unless valid_regions.include?(reg)
+        reg
+      end
+
+      def generate_uid(name)
+        if self.specific_uid.is_a?(Proc)
+          self.specific_uid.call(name)
+        else
+          "#{Time.now.strftime '%Y/%m/%d/%H/%M/%S'}/#{rand(1000)}/#{name.gsub(/[^\w.]+/, '_')}"
+        end
+      end
+
+      def full_storage_headers(headers, meta)
+        {'x-amz-meta-extra' => marshal_encode(meta)}.merge(storage_headers).merge(headers)
+      end
+
+      def parse_s3_metadata(headers)
+        encoded_meta = headers['x-amz-meta-extra']
+        (marshal_decode(encoded_meta) if encoded_meta) || {}
+      end
+
+      def valid_regions
+        REGIONS.keys
+      end
+
+    end
+
+  end
+end