cloud_tempfile 0.0.1

data/lib/cloud_tempfile/config.rb

@@ -0,0 +1,206 @@
+# cloud_tempfile/config.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+module CloudTempfile
+  class Config
+    include ActiveModel::Validations
+
+    # CloudTempfile
+    attr_accessor :enabled
+
+    attr_accessor :prefix
+    attr_accessor :public
+    attr_accessor :public_path
+    attr_accessor :expiry
+    attr_accessor :clean_up
+    attr_accessor :clean_up_older_than
+
+    # FOG configuration
+    attr_accessor :fog_host              #
+    attr_accessor :fog_provider          # Currently Supported ['AWS', 'Google', 'Rackspace', 'Local']
+    attr_accessor :fog_directory         # e.g. 'the-bucket-name'
+    attr_accessor :fog_region            # e.g. 'eu-west-1' or 'us-east-1' etc...
+    attr_accessor :fog_endpoint          # e.g. '/'
+
+    # Amazon AWS
+    attr_accessor :aws_access_key_id, :aws_secret_access_key, :aws_reduced_redundancy, :aws_access_control_list
+
+    # Rackspace
+    attr_accessor :rackspace_username, :rackspace_api_key, :rackspace_auth_url
+
+    # Google Storage
+    attr_accessor :google_storage_secret_access_key, :google_storage_access_key_id
+
+    # Logging Options
+    attr_accessor :fail_silently
+    attr_accessor :log_silently
+
+    # Validation #######################################################################################################
+    validates :public,                :presence => true
+    validates :fog_provider,          :presence => true
+    validates :fog_directory,         :presence => true
+
+    validates :aws_access_key_id,     :presence => true, :if => :aws?
+    validates :aws_secret_access_key, :presence => true, :if => :aws?
+    validates :rackspace_username,    :presence => true, :if => :rackspace?
+    validates :rackspace_api_key,     :presence => true, :if => :rackspace?
+    validates :google_storage_secret_access_key,  :presence => true, :if => :google?
+    validates :google_storage_access_key_id,      :presence => true, :if => :google?
+
+    ####################################################################################################################
+    def initialize
+      self.fog_region = nil
+      self.fog_endpoint = '/'
+
+      self.public = false
+      self.prefix = "tmp/"
+
+      self.fail_silently = false
+      self.log_silently = true
+
+      self.clean_up = false
+      self.clean_up_older_than = 600
+
+      load_yml! if defined?(Rails) && yml_exists?
+    end
+
+    def enabled?
+      enabled == true
+    end
+
+    def public?
+      public == true
+    end
+
+    def public_path
+      @public_path || Rails.public_path
+    end
+
+    def expiry?
+      !expiry.nil? && expiry.kind_of?(Fixnum)
+    end
+
+    def aws?
+      fog_provider == 'AWS'
+    end
+
+    def aws_rrs?
+      aws_reduced_redundancy == true
+    end
+
+    # Set file's access control list (ACL).
+    # Valid acls: private, public-read, public-read-write, authenticated-read, bucket-owner-read, bucket-owner-full-control
+    def aws_acl?
+      ['private', 'public-read', 'public-read-write', 'authenticated-read', 'bucket-owner-read', 'bucket-owner-full-control'].include?(aws_access_control_list)
+    end
+
+    def rackspace?
+      fog_provider == 'Rackspace'
+    end
+
+    def google?
+      fog_provider == 'Google'
+    end
+
+    def local?
+      fog_provider == 'Local'
+    end
+
+    def clean_up?
+      clean_up == true
+    end
+
+    def fog_options
+      #If the CloudTempfile is disabled then revert to local file creation
+      @fog_provider = 'Local' if (!enabled? && !fog_provider.nil?)
+
+      options = { :provider => fog_provider }
+      if aws?
+        options.merge!({
+          :aws_access_key_id => aws_access_key_id,
+          :aws_secret_access_key => aws_secret_access_key
+        })
+        options.merge!({:host => fog_host}) if !fog_host.blank?
+      elsif rackspace?
+        options.merge!({
+          :rackspace_username => rackspace_username,
+          :rackspace_api_key => rackspace_api_key
+        })
+        options.merge!({
+          :rackspace_region => fog_region
+        }) if fog_region
+        options.merge!({ :rackspace_auth_url => rackspace_auth_url }) if rackspace_auth_url
+      elsif google?
+        options.merge!({
+          :google_storage_secret_access_key => google_storage_secret_access_key,
+          :google_storage_access_key_id => google_storage_access_key_id
+        })
+      elsif local?
+        options.merge!({
+          :local_root => public_path,
+          :endpoint => fog_endpoint
+        })
+      else
+        raise ArgumentError, "CloudTempfile Unknown provider: #{fog_provider} only AWS, Rackspace and Google are supported currently."
+      end
+
+      options.merge!({:region => fog_region}) if fog_region && !rackspace?
+      return options
+    end
+
+
+    def yml_exists?
+      defined?(Rails.root) ? File.exists?(self.yml_path) : false
+    end
+
+    def yml
+      begin
+        @yml ||= YAML.load(ERB.new(IO.read(yml_path)).result)[Rails.env] rescue nil || {}
+      rescue Psych::SyntaxError
+        @yml = {}
+      end
+    end
+
+    def yml_path
+      Rails.root.join("config", "cloud_tempfile.yml").to_s
+    end
+
+    def load_yml!
+      self.enabled                = yml["enabled"] if yml.has_key?('enabled')
+
+      self.fog_provider           = yml["fog_provider"]
+      self.fog_directory          = yml["fog_directory"]
+      self.fog_region             = yml["fog_region"]
+      self.fog_host               = yml["fog_host"] if yml.has_key?("fog_host")
+      self.aws_access_key_id      = yml["aws_access_key_id"]
+      self.aws_secret_access_key  = yml["aws_secret_access_key"]
+      self.aws_reduced_redundancy = yml["aws_reduced_redundancy"]
+      self.rackspace_username     = yml["rackspace_username"]
+      self.rackspace_auth_url     = yml["rackspace_auth_url"] if yml.has_key?("rackspace_auth_url")
+      self.rackspace_api_key      = yml["rackspace_api_key"]
+      self.google_storage_secret_access_key = yml["google_storage_secret_access_key"]
+      self.google_storage_access_key_id     = yml["google_storage_access_key_id"]
+
+      self.clean_up               = yml["clean_up"] if yml.has_key?("clean_up")
+      self.clean_up_older_than    = yml["clean_up_older_than"] if yml.has_key?("clean_up_older_than")
+      self.fail_silently          = yml["fail_silently"] if yml.has_key?("fail_silently")
+      self.prefix                 = yml["prefix"] if yml.has_key?("prefix")
+      self.public_path            = yml["public_path"] if yml.has_key?("public_path")
+      self.expiry                 = yml["expiry"] if yml.has_key?("expiry")
+    end
+
+    def fail_silently?
+      fail_silently || !enabled?
+    end
+
+    def log_silently?
+      self.log_silently == false
+    end
+
+    class Invalid < StandardError; end
+    private
+  end
+end

data/lib/cloud_tempfile/engine.rb

@@ -0,0 +1,53 @@
+# cloud_tempfile/engine.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+module CloudTempfile
+  class Engine < Rails::Engine
+
+    engine_name "cloud_tempfile"
+
+    initializer "cloud_tempfile config", :group => :all do |app|
+      app_initializer = Rails.root.join('config', 'initializers', 'cloud_tempfile.rb').to_s
+      app_yaml = Rails.root.join('config', 'cloud_tempfile.yml').to_s
+
+      if File.exists?( app_initializer )
+        CloudTempfile.log "CloudTempfile: using #{app_initializer}"
+        load app_initializer
+      elsif !File.exists?( app_initializer ) && !File.exists?( app_yaml )
+        CloudTempfile.log "CloudTempfile: using default configuration from built-in initializer"
+        CloudTempfile.configure do |config|
+          config.fog_provider = ENV['FOG_PROVIDER'] if ENV.has_key?('FOG_PROVIDER')
+          config.fog_directory = ENV['FOG_DIRECTORY'] if ENV.has_key?('FOG_DIRECTORY')
+          config.fog_region = ENV['FOG_REGION'] if ENV.has_key?('FOG_REGION')
+
+          config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID'] if ENV.has_key?('AWS_ACCESS_KEY_ID')
+          config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'] if ENV.has_key?('AWS_SECRET_ACCESS_KEY')
+          config.aws_reduced_redundancy = ENV['AWS_REDUCED_REDUNDANCY'] == true  if ENV.has_key?('AWS_REDUCED_REDUNDANCY')
+
+          config.rackspace_username = ENV['RACKSPACE_USERNAME'] if ENV.has_key?('RACKSPACE_USERNAME')
+          config.rackspace_api_key = ENV['RACKSPACE_API_KEY'] if ENV.has_key?('RACKSPACE_API_KEY')
+
+          config.google_storage_access_key_id = ENV['GOOGLE_STORAGE_ACCESS_KEY_ID'] if ENV.has_key?('GOOGLE_STORAGE_ACCESS_KEY_ID')
+          config.google_storage_secret_access_key = ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY'] if ENV.has_key?('GOOGLE_STORAGE_SECRET_ACCESS_KEY')
+
+          config.enabled = (ENV['CLOUD_TEMPFILE_ENABLED'] == 'true') if ENV.has_key?('CLOUD_TEMPFILE_ENABLED')
+          config.public = (ENV['CLOUD_TEMPFILE_PUBLIC'] == 'true') if ENV.has_key?('CLOUD_TEMPFILE_PUBLIC')
+          config.public_path = ENV['CLOUD_TEMPFILE_PUBLIC_PATH'] if ENV.has_key?('CLOUD_TEMPFILE_PUBLIC_PATH')
+          config.expiry = ENV['CLOUD_TEMPFILE_EXPIRY'] if ENV.has_key?('CLOUD_TEMPFILE_EXPIRY')
+
+          config.clean_up = (ENV['CLOUD_TEMPFILE_CLEAN_UP'] == 'true') if ENV.has_key?('CLOUD_TEMPFILE_CLEAN_UP')
+          config.clean_up_older_than = ENV['CLOUD_TEMPFILE_CLEAN_UP_OLDER_THAN'] if ENV.has_key?('CLOUD_TEMPFILE_CLEAN_UP_OLDER_THAN')
+        end
+
+        config.prefix = ENV['CLOUD_TEMPFILE_PREFIX'] if ENV.has_key?('CLOUD_TEMPFILE_PREFIX')
+      end
+
+      if File.exists?( app_yaml )
+        CloudTempfile.log "CloudTempfile: YAML file found #{app_yaml} settings will be merged into the configuration"
+      end
+    end
+  end
+end

data/lib/cloud_tempfile/multi_mime.rb

@@ -0,0 +1,22 @@
+# -*- ruby encoding: utf-8 -*-
+#
+# cloud_tempfile/multi_mime.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+module CloudTempfile
+  class MultiMime
+    def self.lookup(ext)
+      if defined?(Mime::Type)
+        Mime::Type.lookup_by_extension(ext)
+      elsif defined?(Rack::Mime)
+        ext_with_dot = ".#{ext}"
+        Rack::Mime.mime_type(ext_with_dot)
+      else
+        MIME::Types.type_for(ext).first
+      end
+    end
+  end
+end

data/lib/cloud_tempfile/railtie.rb

@@ -0,0 +1,11 @@
+# cloud_tempfile/railtie.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+class Rails::Railtie::Configuration
+  def cloud_tempfile
+    CloudTempfile.config
+  end
+end

data/lib/cloud_tempfile/storage.rb

@@ -0,0 +1,151 @@
+# cloud_tempfile/storage.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+module CloudTempfile
+  class Storage
+
+    attr_accessor :config
+
+    def initialize(cfg)
+      @config = cfg
+    end
+
+    # This "connection" is the fog connection responsible for persisting the file
+    # @return [Fog::Storage]
+    def connection
+      @connection ||= ::Fog::Storage.new(self.config.fog_options)
+    end
+
+    # This "directory" action should only be used with the cloud provider and returns a <tt>Fog::Storage::Directory</tt> class
+    # @return [Fog::Storage::Directory]
+    def directory(options={})
+      prefix = options.has_key?(:prefix)? options[:prefix] : self.config.prefix
+      @directory ||= connection.directories.get(self.config.fog_directory, :prefix => prefix)
+    end
+
+    # This action will upload a AWS::File to the specified directory
+    # @return [Fog::Storage::File]
+    def upload_file(f, body, options={})
+      file = init_fog_file(f, body, options)
+      if self.config.enabled?
+        return directory(options).files.create( file )
+      else
+        return local_file(f, body, options)
+      end
+    end
+
+    # Used with the "Local" provider which will utilize the local file system with Fog.
+    # This is handy for development and test environments.
+    # @return [Fog::Storage::Local::File]
+    def local_file(f, body, options={})
+      #return !self.config.public?
+      file = init_fog_file(f, body, options)
+      # If the "file" is empty then return nil
+      return nil if file.nil? || file.blank? || local_root.nil?
+      file = local_root(options).files.create( file )
+    end
+
+    # This action will delete a AWS::File from the specified directory
+    # @param [Fog::Storage::File]
+    def delete_file(f)
+      #return false if !f.kind_of?(Fog::Storage::AWS::File) || !storage_provider.eql?(:aws)
+      log "Deleting: #{f.key}"
+      return f.destroy
+    end
+
+    # Returns a list of remote files for the specified directory
+    # @throws [BucketNotFound]
+    # @return [Array]
+    def get_remote_files
+      raise BucketNotFound.new("#{self.config.fog_provider} Bucket: #{self.config.fog_directory} not found.") unless directory
+      files = []
+      directory.files.each { |f| files << f.key if File.extname(f.key).present? }
+      return files
+    end
+
+    # Delete the expired file which are expired if the "config.clean_up" is true
+    # and "config.clean_up_older_than" is the amount of seconds it is older than.
+    #
+    # Note: This action should be used with the "bundle exec rake cloud_temp_file:clear" rake command (cronjob)
+    def delete_expired_tempfiles
+      return if !self.config.clean_up? || !self.config.enabled?
+      log "CloudTempfile.delete_expired_tempfiles is running..."
+      # Delete expired temp files
+      get_remote_files.each do |f|
+        f = directory.files.get(f)
+        if f.last_modified <= self.config.clean_up_older_than.ago
+          delete_file(f)
+        end
+      end
+      log "CloudTempfile.delete_expired_tempfiles is complete!"
+    end
+
+    # Custom Errors (Exceptions)
+    class BucketNotFound < StandardError; end
+
+    private
+
+    # Initialize a Hash object to be use to by <tt>Fog::Storage</tt> to persist
+    # @param [String] filename
+    # @param [Object] body
+    # @return [Hash]
+    def init_fog_file(filename, body, options={})
+      # If the "filename" or the "body" are empty then return nil
+      return nil if filename.nil? || body.nil?
+      # Set file's access control list (ACL).
+
+      aws_acl = (self.config.aws_acl?)? self.config.aws_access_control_list.to_s : nil
+      # expiry is the number of seconds the file will available publicly
+      expiry = (self.config.expiry?)? self.config.expiry.to_i : nil
+      ext = File.extname(filename)[1..-1] # The file extension
+      mime = MultiMime.lookup(ext) # Look up the content type based off the file extension
+      prefix = options.has_key?(:prefix)? options[:prefix] : self.config.prefix
+      full_filename = (self.config.local? || !self.config.enabled?)? filename : "#{prefix}#{filename}"
+
+      # file Hash to be used to create a Fog for upload
+      file = {
+        :key => "#{full_filename}",
+        :body => body,
+        :content_type => mime
+      }
+
+      file.merge!({:public => true}) if self.config.public?
+
+      if self.config.aws?
+        if self.config.public? && self.config.expiry?
+          file.merge!({:cache_control => "public, max-age=#{expiry}"})
+        end
+        # valid acls: private, public-read, public-read-write, authenticated-read, bucket-owner-read, bucket-owner-full-control
+        file.merge!({:acl=>self.config.aws_access_control_list.to_s}) if self.config.aws_acl?
+        file.merge!({:expires => Time.now.utc.to_i + expiry}) if self.config.expiry?
+        file.merge!({:storage_class => 'REDUCED_REDUNDANCY'}) if self.config.aws_rrs?
+      end
+
+      return file
+    end
+
+    # This "local_root" action should only be used with the "Local" provider and returns a Fog::Storage::Local::Directory class
+    # @return [Fog::Storage::Local::Directory]
+    def local_root(options={})
+      prefix = options.has_key?(:prefix)? options[:prefix] : self.config.prefix
+
+      begin
+        if !connection.directories.get(prefix).nil?
+          @local_root ||= connection.directories.get(prefix)
+        else
+          @local_root ||= connection.directories.create(:key => prefix)
+        end
+      rescue
+        @local_root ||= connection.directories.create(:key => prefix)
+      end
+    end
+
+    def log(msg)
+      CloudTempfile.log(msg)
+    end
+
+  end
+end

data/lib/cloud_tempfile/version.rb

@@ -0,0 +1,9 @@
+# cloud_tempfile/version.rb
+#
+# Author::    Kevin Bolduc
+# Date::      14-02-24
+# Time::      3:23 PM
+
+module CloudTempfile
+  VERSION = "0.0.1"
+end

data/lib/cloud_tempfile.rb

@@ -0,0 +1,11 @@
+require 'fog'
+require 'active_model'
+require 'erb'
+require "ext/fog/aws/models/storage/file"
+require 'cloud_tempfile/cloud_tempfile'
+require 'cloud_tempfile/config'
+require 'cloud_tempfile/storage'
+require 'cloud_tempfile/multi_mime'
+
+require 'cloud_tempfile/railtie' if defined?(Rails)
+require 'cloud_tempfile/engine'  if defined?(Rails)

data/lib/ext/fog/aws/models/storage/file.rb

@@ -0,0 +1,19 @@
+require 'fog/aws/models/storage/file'
+
+module Fog
+  module Storage
+    class AWS
+
+      class File
+        fog_public_url = instance_method(:public_url)
+
+        define_method(:public_url) do
+          return_url = fog_public_url.bind(self).call()
+          return_url = url(expires) if return_url.nil? && !expires.nil?
+          return return_url
+        end
+      end
+
+    end
+  end
+end

data/lib/generators/cloud_tempfile/install_generator.rb

@@ -0,0 +1,71 @@
+require 'rails/generators'
+module CloudTempfile
+  class InstallGenerator < Rails::Generators::Base
+    desc "Install a config/cloud_tempfile.yml "
+
+    # Commandline options can be defined here using Thor-like options:
+    class_option :use_yml,   :type => :boolean, :default => false, :desc => "Use YML file instead of Rails Initializer"
+    class_option :provider,  :type => :string,  :default => "AWS",  :desc => "Generate with support for 'AWS', 'Rackspace', or 'Google'"
+
+    def self.source_root
+      @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def aws?
+      options[:provider] == 'AWS'
+    end
+
+    def google?
+      options[:provider] == 'Google'
+    end
+
+    def rackspace?
+      options[:provider] == 'Rackspace'
+    end
+
+    def fog_directory
+      "<%= ENV['FOG_DIRECTORY'] %>"
+    end
+
+    def aws_access_key_id
+      "<%= ENV['AWS_ACCESS_KEY_ID'] %>"
+    end
+
+    def aws_secret_access_key
+      "<%= ENV['AWS_SECRET_ACCESS_KEY'] %>"
+    end
+
+    def google_storage_access_key_id
+      "<%= ENV['GOOGLE_STORAGE_ACCESS_KEY_ID'] %>"
+    end
+
+    def google_storage_secret_access_key
+      "<%= ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY'] %>"
+    end
+
+    def rackspace_username
+      "<%= ENV['RACKSPACE_USERNAME'] %>"
+    end
+
+    def rackspace_api_key
+      "<%= ENV['RACKSPACE_API_KEY'] %>"
+    end
+
+    def app_name
+      @app_name ||= Rails.application.is_a?(Rails::Application) && Rails.application.class.name.sub(/::Application$/, "").downcase
+    end
+
+    def generate_config
+      if options[:use_yml]
+        template "cloud_tempfile.yml", "config/cloud_tempfile.yml"
+      end
+    end
+
+    def generate_initializer
+      unless options[:use_yml]
+        template "cloud_tempfile.rb", "config/initializers/cloud_tempfile.rb"
+      end
+    end
+
+  end
+end

data/lib/generators/cloud_tempfile/templates/cloud_tempfile.rb

@@ -0,0 +1,41 @@
+CloudTempfile.configure do |config|
+  # Enable or disable the CloudTempfile functionality (Default: true)
+  # config.enabled = true
+  <%- if aws? -%>
+  config.fog_provider = 'AWS'
+  config.aws_access_key_id = ENV['AWS_ACCESS_KEY_ID']
+  config.aws_secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+  # The name of Amason S3 Bucket
+  config.fog_directory = ENV['FOG_DIRECTORY']
+  # You may need to specify what region your storage bucket is in. This may increase upload performance by configuring your region
+  # config.fog_region = 'eu-west-1'
+  # To use AWS reduced redundancy storage.
+  # (http://aws.amazon.com/about-aws/whats-new/2010/05/19/announcing-amazon-s3-reduced-redundancy-storage/)
+  # config.aws_reduced_redundancy = true
+  <%- elsif google? -%>
+  config.fog_provider = 'Google'
+  config.fog_directory = ENV['FOG_DIRECTORY']
+  config.google_storage_access_key_id = ENV['GOOGLE_STORAGE_ACCESS_KEY_ID']
+  config.google_storage_secret_access_key = ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY']
+  <%- elsif rackspace? -%>
+  config.fog_provider = 'Rackspace'
+  config.fog_directory = ENV['FOG_DIRECTORY']
+  config.rackspace_username = ENV['RACKSPACE_USERNAME']
+  config.rackspace_api_key = ENV['RACKSPACE_API_KEY']
+  # if you need to change rackspace_auth_url (e.g. if you need to use Rackspace London)
+  # config.rackspace_auth_url = "lon.auth.api.rackspacecloud.com"
+  <%- end -%>
+  #
+  # (String) This is a string file path which will be appended to the filename
+  # config.prefix =  "<%= ENV['RAILS_ENV'] %>/tmp/"
+  # (Boolean) When true, the file publicly accessible. When false (default), a authenticated url will attempt to be generated
+  # config.public = true
+  # (Integer) The number of seconds the authenticated url will be valid (600 seconds = 10 minutes)
+  # config.expiry = 600
+  # (Boolean) When true, the clean up task (CloudTempfile.clear) will be able to run. Perfect for a cron clean up! ;)
+  # config.clean_up = true
+  # (Integer) The number of seconds the authenticated url will be valid (3600 seconds = 1 hour)
+  # config.clean_up_older_than = 3600
+  # (Boolean) Useful for environments such as Heroku
+  # config.fail_silently = true
+end

data/lib/generators/cloud_tempfile/templates/cloud_tempfile.yml

@@ -0,0 +1,52 @@
+defaults: &defaults
+  # Enable or disable the CloudTempfile functionality (Default: true)
+  # enabled: true
+  <%- if aws? -%>
+  fog_provider: "AWS"
+  aws_access_key_id: "<%= aws_access_key_id %>"
+  aws_secret_access_key: "<%= aws_secret_access_key %>"
+  # The name of Amason S3 Bucket
+  fog_directory: "<%= fog_directory %>"
+  # You may need to specify what region your storage bucket is in. This may increase upload performance by configuring your region
+  # fog_region: "us-east-1"
+  # To use AWS reduced redundancy storage.
+  # (http://aws.amazon.com/about-aws/whats-new/2010/05/19/announcing-amazon-s3-reduced-redundancy-storage/)
+  # aws_reduced_redundancy: true
+  <%- elsif google? -%>
+  fog_provider: "Google"
+  fog_directory: "<%= fog_directory %>"
+  google_storage_access_key_id: "<%= google_storage_access_key_id %>"
+  google_storage_secret_access_key: "<%= google_storage_secret_access_key %>"
+  <%- elsif rackspace? -%>
+  fog_provider: "Rackspace"
+  fog_directory: "name_of_container"
+  rackspace_username: "<%= rackspace_username %>"
+  rackspace_api_key: "<%= rackspace_api_key %>"
+  # if you need to change rackspace_auth_url (e.g. if you need to use Rackspace London)
+  # rackspace_auth_url: "https://lon.identity.api.rackspacecloud.com/v2.0"
+  <%- end -%>
+  # (String) This is a string file path which will be appended to the filename
+  # prefix: "<%= ENV['RAILS_ENV'] %>/tmp/"
+  # (Boolean) When true, the file publicly accessible. When false (default), a authenticated url will attempt to be generated
+  # public: true
+  # (Integer) The number of seconds the authenticated url will be valid (600 seconds = 10 minutes)
+  # expiry: 600
+  # (Boolean) When true, the clean up task (CloudTempfile.clear) will be able to run. Perfect for a cron clean up! ;)
+  # clean_up: true
+  # (Integer) The number of seconds the authenticated url will be valid (3600 seconds = 1 hour)
+  # clean_up_older_than: 3600
+  # (Boolean) Useful for environments such as Heroku
+  # fail_silently: true
+development:
+  <<: *defaults
+  enabled: false
+
+test:
+  <<: *defaults
+  enabled: false
+
+staging:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/lib/tasks/cloud_tempfile_tasks.rake

@@ -0,0 +1,7 @@
+namespace :cloud_tempfile do
+  desc "Clean up expired temp files from the remote storage"
+  task :clear => :environment do
+    CloudTempfile.clear
+  end
+end
+