carrierwave 0.5.2 → 0.5.3

data/lib/carrierwave/storage/fog.rb

@@ -0,0 +1,317 @@
+# encoding: utf-8
+
+begin
+  require 'fog'
+rescue LoadError
+  raise "You don't have the 'fog' gem installed"
+end
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Stores things using the "fog" gem.
+    #
+    # fog supports storing files with AWS, Google, Local and Rackspace
+    #
+    # You need to setup some options to configure your usage:
+    #
+    # [:fog_credentials]  credentials for service
+    # [:fog_directory]    specifies name of directory to store data in
+    #
+    # [:fog_attributes]                   (optional) additional attributes to set on files
+    # [:fog_host]                         (optional) non-default host to serve files from
+    # [:fog_public]                       (optional) public readability, defaults to true
+    # [:fog_authenticated_url_expiration] (optional) time (in seconds) that authenticated urls
+    #   will be valid, when fog_public is false and provider is AWS or Google, defaults to 600
+    #
+    #
+    # AWS credentials contain the following keys:
+    #
+    # [:aws_access_key_id]
+    # [:aws_secret_access_key]
+    # [:region]                 (optional) defaults to 'us-east-1'
+    #   :region should be one of ['eu-west-1', 'us-east-1', 'ap-southeast-1', 'us-west-1', 'ap-northeast-1']
+    #
+    #
+    # Google credentials contain the following keys:
+    # [:google_storage_access_key_id]
+    # [:google_storage_secrete_access_key]
+    #
+    #
+    # Local credentials contain the following keys:
+    #
+    # [:local_root]             local path to files
+    #
+    #
+    # Rackspace credentials contain the following keys:
+    #
+    # [:rackspace_username]
+    # [:rackspace_api_key]
+    #
+    #
+    # A full example with AWS credentials:
+    #     CarrierWave.configure do |config|
+    #       config.fog_credentials = {
+    #         :aws_access_key_id => 'xxxxxx',
+    #         :aws_secret_access_key => 'yyyyyy',
+    #         :provider => 'AWS'
+    #       }
+    #       config.fog_directory = 'directoryname'
+    #       config.fog_public = true
+    #     end
+    #
+    class Fog < Abstract
+
+      ##
+      # Store a file
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::Fog::File] the stored file
+      #
+      def store!(file)
+        f = CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path)
+        f.store(file)
+        f
+      end
+
+      ##
+      # Retrieve a file
+      #
+      # === Parameters
+      #
+      # [identifier (String)] unique identifier for file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::Fog::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::Fog::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+      def connection
+        @connection ||= begin
+          ::Fog::Storage.new(uploader.fog_credentials)
+        end
+      end
+
+      class File
+
+        ##
+        # Current local path to file
+        #
+        # === Returns
+        #
+        # [String] a path to file
+        #
+        attr_reader :path
+
+        ##
+        # Return all attributes from file
+        #
+        # === Returns
+        #
+        # [Hash] attributes from file
+        #
+        def attributes
+          file.attributes
+        end
+
+        ##
+        # Return a temporary authenticated url to a private file, if available
+        # Only supported for AWS and Google providers
+        #
+        # === Returns
+        #
+        # [String] temporary authenticated url
+        #   or
+        # [NilClass] no authenticated url available
+        #
+        def authenticated_url
+          if ['AWS', 'Google'].include?(@uploader.fog_credentials[:provider])
+            # avoid a get by using local references
+            local_directory = connection.directories.new(:key => @uploader.fog_directory)
+            local_file = local_directory.files.new(:key => path)
+            local_file.url(::Fog::Time.now + @uploader.fog_authenticated_url_expiration)
+          else
+            nil
+          end
+        end
+
+        ##
+        # Lookup value for file content-type header
+        #
+        # === Returns
+        #
+        # [String] value of content-type
+        #
+        def content_type
+          @content_type || file.content_type
+        end
+
+        ##
+        # Set non-default content-type header (default is file.content_type)
+        #
+        # === Returns
+        #
+        # [String] returns new content type value
+        #
+        def content_type=(new_content_type)
+          @content_type = new_content_type
+        end
+
+        ##
+        # Remove the file from service
+        #
+        # === Returns
+        #
+        # [Boolean] true for success or raises error
+        #
+        def delete
+          file.destroy
+        end
+
+        ##
+        # deprecated: All attributes from file (includes headers)
+        #
+        # === Returns
+        #
+        # [Hash] attributes from file
+        #
+        def headers
+          location = caller.first
+          warning = "[yellow][WARN] headers is deprecated, use attributes instead[/]"
+          warning << " [light_black](#{location})[/]"
+          Formatador.display_line(warning)
+          attributes
+        end
+
+        def initialize(uploader, base, path)
+          @uploader, @base, @path = uploader, base, path
+        end
+
+        ##
+        # Read content of file from service
+        #
+        # === Returns
+        #
+        # [String] contents of file
+        def read
+          file.body
+        end
+
+        ##
+        # Return size of file body
+        #
+        # === Returns
+        #
+        # [Integer] size of file body
+        #
+        def size
+          file.content_length
+        end
+
+        ##
+        # Write file to service
+        #
+        # === Returns
+        #
+        # [Boolean] true on success or raises error
+        def store(new_file)
+          @content_type ||= new_file.content_type
+          @file = directory.files.create({
+            :body         => new_file.read,
+            :content_type => @content_type,
+            :key          => path,
+            :public       => @uploader.fog_public
+          }.merge(@uploader.fog_attributes))
+          true
+        end
+
+        ##
+        # Return a url to a public file, if available
+        #
+        # === Returns
+        #
+        # [String] public url
+        #   or
+        # [NilClass] no public url available
+        #
+        def public_url
+          if host = @uploader.fog_host
+            "#{host}/#{path}"
+          else
+            # avoid a get by just using local reference
+            directory.files.new(:key => path).public_url
+          end
+        end
+
+        ##
+        # Return url to file, if avaliable
+        #
+        # === Returns
+        #
+        # [String] url
+        #   or
+        # [NilClass] no url available
+        #
+        def url
+          if !@uploader.fog_public
+            authenticated_url
+          else
+            public_url
+          end
+        end
+
+      private
+
+        ##
+        # connection to service
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::Storage] connection to service
+        #
+        def connection
+          @base.connection
+        end
+
+        ##
+        # lookup directory containing file
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::Directory] containing directory
+        #
+        def directory
+          @directory ||= begin
+            connection.directories.get(@uploader.fog_directory) || connection.directories.create(
+              :key    => @uploader.fog_directory,
+              :public => @uploader.fog_public
+            )
+          end
+        end
+
+        ##
+        # lookup file
+        #
+        # === Returns
+        #
+        # [Fog::#{provider}::File] file data from remote service
+        #
+        def file
+          @file ||= directory.files.get(path)
+        end
+
+      end
+
+    end # Fog
+
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/s3.rb

@@ -132,7 +132,7 @@ module CarrierWave
         end
 
         def authenticated_url
-          connection.get_object_url(bucket, path, Time.now + 60 * 10)
+          connection.get_object_url(bucket, path, Time.now + authentication_timeout)
         end
 
         def store(file)
@@ -184,6 +184,10 @@ module CarrierWave
           @uploader.s3_bucket
         end
 
+        def authentication_timeout
+          @uploader.s3_authentication_timeout
+        end
+
         def connection
           @base.connection
         end
@@ -222,11 +226,11 @@ module CarrierWave
       end
 
       def connection
-        @connection ||= Fog::Storage.new(
-          :provider => 'AWS',
-          :aws_access_key_id => uploader.s3_access_key_id,
-          :aws_secret_access_key => uploader.s3_secret_access_key,
-          :region => uploader.s3_region
+        @connection ||= ::Fog::Storage.new(
+          :aws_access_key_id      => uploader.s3_access_key_id,
+          :aws_secret_access_key  => uploader.s3_secret_access_key,
+          :provider               => 'AWS',
+          :region                 => uploader.s3_region
         )
       end
 

data/lib/carrierwave/uploader/cache.rb

@@ -63,6 +63,19 @@ module CarrierWave
         @cache_id
       end
 
+      ##
+      # Caches the remotely stored file
+      #
+      # This is useful when about to process images. Most processing solutions
+      # require the file to be stored on the local filesystem.
+      #
+      def cache_stored_file!
+        sanitized = SanitizedFile.new :tempfile => StringIO.new(file.read),
+          :filename => File.basename(path), :content_type => file.content_type
+
+        cache! sanitized
+      end
+
       ##
       # Returns a String which uniquely identifies the currently cached file for later retrieval
       #
@@ -87,9 +100,10 @@ module CarrierWave
       #
       def cache!(new_file)
         new_file = CarrierWave::SanitizedFile.new(new_file)
-        raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
 
         unless new_file.empty?
+          raise CarrierWave::FormNotMultipart if new_file.is_path? && ensure_multipart_form
+
           with_callbacks(:cache, new_file) do
             self.cache_id = CarrierWave.generate_cache_id unless cache_id
 

data/lib/carrierwave/uploader/configuration.rb

@@ -16,10 +16,13 @@ module CarrierWave
         add_config :s3_headers
         add_config :s3_region
         add_config :s3_use_ssl
+        add_config :s3_authentication_timeout
         add_config :cloud_files_username
         add_config :cloud_files_api_key
         add_config :cloud_files_container
         add_config :cloud_files_cdn_host
+        add_config :cloud_files_auth_url
+        add_config :cloud_files_snet
         add_config :grid_fs_connection
         add_config :grid_fs_database
         add_config :grid_fs_host
@@ -33,6 +36,14 @@ module CarrierWave
         add_config :ensure_multipart_form
         add_config :delete_tmp_file_after_storage
 
+        # fog
+        add_config :fog_attributes
+        add_config :fog_credentials
+        add_config :fog_directory
+        add_config :fog_host
+        add_config :fog_public
+        add_config :fog_authenticated_url_expiration
+
         # Mounting
         add_config :ignore_integrity_errors
         add_config :ignore_processing_errors
@@ -40,34 +51,8 @@ module CarrierWave
         add_config :validate_processing
         add_config :mount_on
 
-        configure do |config|
-          config.permissions = 0644
-          config.storage_engines = {
-            :file => "CarrierWave::Storage::File",
-            :s3 => "CarrierWave::Storage::S3",
-            :grid_fs => "CarrierWave::Storage::GridFS",
-            :right_s3 => "CarrierWave::Storage::RightS3",
-            :cloud_files => "CarrierWave::Storage::CloudFiles"
-          }
-          config.storage = :file
-          config.s3_headers = {}
-          config.s3_access_policy = :public_read
-          config.s3_region = 'us-east-1'
-          config.s3_use_ssl = false
-          config.grid_fs_database = 'carrierwave'
-          config.grid_fs_host = 'localhost'
-          config.grid_fs_port = 27017
-          config.store_dir = 'uploads'
-          config.cache_dir = 'uploads/tmp'
-          config.delete_tmp_file_after_storage = true
-          config.ignore_integrity_errors = true
-          config.ignore_processing_errors = true
-          config.validate_integrity = true
-          config.validate_processing = true
-          config.root = CarrierWave.root
-          config.enable_processing = true
-          config.ensure_multipart_form = true
-        end
+        # set default values
+        reset_config
       end
 
       module ClassMethods
@@ -132,6 +117,45 @@ module CarrierWave
         def configure
           yield self
         end
+
+        ##
+        # sets configuration back to default
+        #
+        def reset_config
+          configure do |config|
+            config.permissions = 0644
+            config.storage_engines = {
+              :file => "CarrierWave::Storage::File",
+              :fog => "CarrierWave::Storage::Fog",
+              :s3 => "CarrierWave::Storage::S3",
+              :grid_fs => "CarrierWave::Storage::GridFS",
+              :right_s3 => "CarrierWave::Storage::RightS3",
+              :cloud_files => "CarrierWave::Storage::CloudFiles"
+            }
+            config.storage = :file
+            config.s3_headers = {}
+            config.s3_access_policy = :public_read
+            config.s3_region = 'us-east-1'
+            config.s3_authentication_timeout = 600
+            config.grid_fs_database = 'carrierwave'
+            config.grid_fs_host = 'localhost'
+            config.grid_fs_port = 27017
+            config.fog_attributes = {}
+            config.fog_credentials = {}
+            config.fog_public = true
+            config.fog_authenticated_url_expiration = 600
+            config.store_dir = 'uploads'
+            config.cache_dir = 'uploads/tmp'
+            config.delete_tmp_file_after_storage = true
+            config.ignore_integrity_errors = true
+            config.ignore_processing_errors = true
+            config.validate_integrity = true
+            config.validate_processing = true
+            config.root = CarrierWave.root
+            config.enable_processing = true
+            config.ensure_multipart_form = true
+          end
+        end
       end
 
     end